Java多线程之syncrhoized内置互斥锁的用法详解

转载请注明原文地址：http://www.cnblogs.com/ygj0930/p/5827547.html

解决并行冲突最有效的方法就是加同步锁，主要有以下几种方法：

1：动态方法同步锁:锁当前类对象。即调用该方法的类对象优先执行完毕才到下一个线程执行。
public synchronized void 方法()
{
}
实例代码：

import java.lang.Thread.State;

import org.omg.CORBA.PUBLIC_MEMBER;

public class ThreadTest {
public static void main(String[] args) throws Exception{
MyRunnable m1=new MyRunnable();
Thread t1=new Thread(m1);
Thread t2=new Thread(m1);
t1.start();
t2.start();
t1.join();
t2.join();
System.out.println(MyRunnable.num);
}
}
class MyRunnable implements Runnable
{
public static int num=0;
public synchronized void add()
{
for(int i=0;i<100;++i)
{
num++;
}
}
@Override
public void run() {
add();
}
}

结果：200

2：静态方法同步锁：锁当前类型。即：该类型的所有类对象优先执行。凡是该类的对象且已经调用运行的，则这些类对象都是平级的，交替运行。而这些对象对于其他类的对象则是优先的，先执行。
public static synchronized void 方法()
{
}
实例：

import java.lang.Thread.State;

import org.omg.CORBA.PUBLIC_MEMBER;

public class ThreadTest {
public static void main(String[] args) throws Exception{
MyRunnable m1=new MyRunnable();
MyRunnable m2=new MyRunnable();
Thread t1=new Thread(m1);
Thread t2=new Thread(m2);
t1.start();
t2.start();

t1.join();
t2.join();
System.out.println(MyRunnable.num);
}
}
class MyRunnable implements Runnable
{
public static int num=0;
public synchronized static void add()
{
for(int i=0;i<100;++i)
{
num++;
}
}
@Override
public void run() {
add();
}
}

结果：200

3：代码同步锁：设置一个锁对象（绣球），用来标识谁来执行被锁的代码块。谁拿到这个对象（抢绣球），谁就执行。
runnable()
{
public Object lock=new Object();
public void 方法()
{
synchronized(lock){代码块｝;
}
}

若两个thread类对象用同一个runnable参数，则lock对象被多线程抢夺。由于lock对象的唯一性，两个线程谁拿到lock对象谁运行被锁代码块，最终结果是确定的。

import java.lang.Thread.State;

import org.omg.CORBA.PUBLIC_MEMBER;

public class ThreadTest {
public static void main(String[] args) throws Exception{
MyRunnable m1=new MyRunnable();

Thread t1=new Thread(m1);
Thread t2=new Thread(m1);
t1.start();
t2.start();

t1.join();
t2.join();
System.out.println(MyRunnable.num);
}
}
class MyRunnable implements Runnable
{
public static int num=0;
public Object lock=new Object();
public void add()
{
synchronized (lock) {
for(int i=0;i<100000;++i)
{
num++;
}
}
}
@Override
public void run() {
add();
}
}

结果：200000

若两个thread类对象不用同一个runnable对象参数，则两个线程分别对应一个lock代码块，两线程独立运行lock代码块，但交替使用CPU，会导致结果飘忽不定。

import java.lang.Thread.State;

import org.omg.CORBA.PUBLIC_MEMBER;

public class ThreadTest {
public static void main(String[] args) throws Exception{
MyRunnable m1=new MyRunnable();
MyRunnable m2=new MyRunnable();
Thread t1=new Thread(m1);
Thread t2=new Thread(m2);
t1.start();
t2.start();

t1.join();
t2.join();
System.out.println(MyRunnable.num);
}
}
class MyRunnable implements Runnable
{
public static int num=0;
public Object lock=new Object();
public void add()
{
synchronized (lock) {
for(int i=0;i<100000;++i)
{
num++;
}
}
}
@Override
public void run() {
add();
}
}

多调试几次：结果是随机的，循环次数越大结果越随机。比如，上面for循环中如果是i<100,那么可能结果总是200，这看起来是对的，没错。原因是循环次数太少，两线程对结果影响不大。当把数字调大，如100000时，结果就很随机了，有可能是103453，112378。。。。。。。