java 多线程系列之线程安全和synchronized

• 什么是线程安全

  简单说来，当多个线程访问某一个类（对象或方法）时，这个对象始终都能表现出正确的行为，那么这个类（对象或方法）就是线程安全的。

  举例说明

public class MyThread extends Thread{
    private int count = 5 ;
    public static void main(String[] args) {
        MyThread myThread = new MyThread();
        Thread t1 = new Thread(myThread,"t1");
        Thread t2 = new Thread(myThread,"t2");
        Thread t3 = new Thread(myThread,"t3");
        Thread t4 = new Thread(myThread,"t4");
        Thread t5 = new Thread(myThread,"t5");
        t1.start();
        t2.start();
        t3.start();
        t4.start();
        t5.start();
    }
    public void run(){
        count--;
        System.out.println(this.currentThread().getName() + " count = "+ count);
    }
}

结果如下

t1 count = 3
t3 count = 2
t5 count = 1
t2 count = 4
t4 count = 0

这里的操作很显然是线程不安全的，当多个线程同时执行count–时，会有多个线程同时得到count变量并进行减操作，所以结果如上所示。
为了实现线程安全，我们引入synchronized对当前对象加锁实现线程安全。

public class MyThread extends Thread{
    private int count = 5 ;
    public static void main(String[] args) {
        MyThread myThread = new MyThread();
        Thread t1 = new Thread(myThread,"t1");
        Thread t2 = new Thread(myThread,"t2");
        Thread t3 = new Thread(myThread,"t3");
        Thread t4 = new Thread(myThread,"t4");
        Thread t5 = new Thread(myThread,"t5");
        t1.start();
        t2.start();
        t3.start();
        t4.start();
        t5.start();
    }
    public synchronized void run(){
        count--;
        System.out.println(this.currentThread().getName() + " count = "+ count);
    }
}

结果如下

t2 count = 4
t4 count = 3
t1 count = 2
t3 count = 1
t5 count = 0

显然这是我们想要的结果。这里对synchronized做一个简单的介绍

• synchronized介绍

  
  synchronized取得的锁都是对象锁，而不是把一段代码（方法）当做锁，
  所以代码中哪个线程先执行synchronized关键字的方法，哪个线程就持有该方法所属对象的锁（Lock）

public class MultiThread {
    private  int num = 0;
    public synchronized void printNum(String tag){
        try {

            if(tag.equals("a")){
                num = 100;
                System.out.println("a赋值num完成");
                Thread.sleep(1000);
            } else {
                num = 200;
                System.out.println("b赋值num完成");
            }

            System.out.println("num = " + num);

        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    //注意观察run方法输出顺序
    public static void main(String[] args) {

        //俩个不同的对象
        final MultiThread m1 = new MultiThread();
        final MultiThread m2 = new MultiThread();

        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                m1.printNum("a");
            }
        });

        Thread t2 = new Thread(new Runnable() {
            @Override 
            public void run() {
                m2.printNum("b");
            }
        });     

        t1.start();
        t2.start();

    }
}

由于synchronized只是对对象m1、m2加锁，所以输出结果如下（不是我们想要的）

b赋值num完成
a赋值num完成
num = 200
num = 100

而我们想要的结果为

a赋值num完成
num = 100
b赋值num完成
num = 200

为了达到这个结果，我们对代码进行改造

public class MultiThread {
    private static int num = 0;
    public synchronized static void printNum(String tag){
        try {

            if(tag.equals("a")){
                num = 100;
                System.out.println("a赋值num完成");
                Thread.sleep(1000);
            } else {
                num = 200;
                System.out.println("b赋值num完成");
            }

            System.out.println("num = " + num);

        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    //注意观察run方法输出顺序
    public static void main(String[] args) {

        //俩个不同的对象
        final MultiThread m1 = new MultiThread();
        final MultiThread m2 = new MultiThread();

        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                m1.printNum("a");
            }
        });

        Thread t2 = new Thread(new Runnable() {
            @Override 
            public void run() {
                m2.printNum("b");
            }
        });     

        t1.start();
        t2.start();

    }
}

输出的结果是我们想要的，这里在静态方法上加synchronized关键字，表示锁定.class类，类一级别的锁（独占.class类）。

synchronized对于代码块的加锁方式比较灵活，如下所示：

    public void method1(){
        synchronized (this) {   //对象锁
            try {
                System.out.println("do method1..");
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public void method2(){      //类锁
        synchronized (ObjectLock.class) {
            try {
                System.out.println("do method2..");
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    private Object lock = new Object();
    public void method3(){      //任何对象锁
        synchronized (lock) {
            try {
                System.out.println("do method3..");
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }