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。。。。。。。