（二）synchronized详解

---

1、了解synchronized

synchronized是Java中的关键字，是一种同步锁。当多个并发线程访问同一个对象中用synchronized修饰的代码块时，在同一时刻只能有一个线程得到执行，其他的线程均受阻塞，必须等待当前线程执行完毕，其他线程才能执行该代码块。
　　当前执行线程和其他线程是互斥的，因为在执行synchronized代码块时会锁定当前的对象，只有执行完该代码块才能释放该对象锁，下一个线程才能执行并锁定该对象。

---

2、使用synchronized修饰方法

实现线程有序计数

class Num implements Runnable {
    private int count;

    public Num() {
        count = 0;
    }

    public synchronized void run() {//获取锁并排斥其他线程
        /*
         * 使用synchronized修饰run()方法 
         * 被修饰的方法称为同步方法 
         * 其作用的范围是整个方法 
         * 作用的对象是调用这个方法的对象
         */
        for (int i = 0; i < 5; i++) {

            System.out.println(Thread.currentThread().getName() + "数了" + (++count));
        }
    }//释放锁

}

public class Demo1 {

    public static void main(String[] args) {
        Num n = new Num();
        /*
         * 使用Thread(Runnable target, String name) 这种构造方法
         * 参数name就是新线程名称
         */
        Thread thread1 = new Thread(n, "Tom");
        Thread thread2 = new Thread(n, "Mike");
        thread1.start();
        thread2.start();
    }

}

使用synchronized修饰的结果如下：
当一个线程在执行任务代码时，另一个线程是被阻塞的，因此只有在Mike计数完成之后，Tom才开始计数。

对之前的代码稍作修改加以对比：

public class Demo1 {
    public static void main(String[] args) {
        Thread thread1 = new Thread(new Num(), "Tom");
        Thread thread2 = new Thread(new Num(), "Mike");
        thread1.start();
        thread2.start();
    }
}

此时结果如下：

之所以出现使用了synchronized修饰，仍然乱序的结果，是因为因为synchronized只锁定对象，每个对象只有一个锁（lock）与之相关联，修改代码后相当于每个线程各自又创建了一个对象，因此存在两个对象以及两把锁，所以出现乱序，这也就意味着如果要使用同步锁，必须保证至少有两个或以上的线程，同时这多个线程都使用同一把锁。

注意：

1. synchronized关键字不能继承。
   　　虽然可以使用synchronized来修饰方法，但synchronized并不属于方法定义的一部分，因此，synchronized关键字不能被继承。如果在父类中的某个方法使用了synchronized关键字，而在子类中重写了这个方法，在子类中的这个方法默认情况下并不是同步的，必须显式地在子类的这个方法中加上synchronized关键字才可以。当然，还可以在子类方法中调用父类中相应的方法，这样虽然子类中的方法不是同步的，但子类调用了父类的同步方法，因此，子类的方法也就相当于同步了。这两种方式的例子代码如下：

//在子类方法中添加synchronized关键字
class Parent {
    public synchronized void fun() {
    }
}
class Child extends Parent {
    public synchronized void fun() {
    }
}

//在子类方法中调用父类的同步方法
class Parent {
    public synchronized void fun() {
    }
}
class Child extends Parent {
    public void fun() {
        super.fun();
    }
}

2. 在创建接口中的方法时不能使用synchronized关键字。
3. 构造方法不能使用synchronized关键字，但可以使用synchronized代码块来进行同步。

---

3、使用synchronized修饰静态方法

静态同步方法在进内存时不存在对象，但是存在其所属类的class类型的字节码文件对象，因此静态同步方法的锁就是该对象(.class)，锁定的是所属类的所有对象。

对 “ 实现线程有序计数 ” 案例做以下修改

class Num implements Runnable {

    // 静态方法需要调用静态变量
    private static int count;

    public Num() {
        count = 0;
    }

    // 定义静态同步方法
    public synchronized static void fun() {

        for (int i = 0; i < 5; i++) {

            System.out.println(Thread.currentThread().getName() + "数了" + (++count));
        }

    }

    // 重写run()方法，调用静态同步方法
    public void run() {
        fun();
    }

}

public class Demo2 {

    public static void main(String[] args) {

        Thread thread1 = new Thread(new Num(), "Tom");
        Thread thread2 = new Thread(new Num(), "Mike");
        thread1.start();
        thread2.start();

    }

}

此时结果如下：

虽然2个线程在执行时分别创建了2个对象，但由于run()方法调用了静态同步方法fun()，静态方法是属于类的，所以这2个对象相当于用了同一把锁，即所属类的字节码文件。虽然结果与Demo1相同，但实现原理是不同的。

---

4、使用synchronized修饰代码块

使用synchronized修饰一个代码块，被修饰的代码块称为同步语句块，其作用的范围是大括号{}括起来的代码，作用的对象是调用这个代码块的对象，例如依然修改上述代码，将修饰方法改为修饰代码块：

class Num implements Runnable {
    private static int count;

    public Num() {
        count = 0;
    }

    public void run() {

        synchronized (this) {
            for (int i = 0; i < 5; i++) {

                System.out.println(Thread.currentThread().getName() + "数了" + (++count));
            }
        }
    }

    public int getCount() {
        return count;
    }
}

运行结果与修饰方法是相同的，只是形式不同，这里在方法内修饰代码块的作用域与直接修饰方法是一样的，都是run()方法内部。

当一个程序内存在使用synchronized修饰的代码块以及普通代码块时，多个线程可以同时访问这些代码块，访问普通代码块的线程之间仍然是争抢CPU的状态，访问同步代码块的线程受同步锁的影响会在结果上呈现先后顺序，示例代码如下：

class Test implements Runnable {
    /*
     * 创建测试类Test继承Runnable接口 
     * 该类包含两个方法 fun1()方法是使用synchronized修饰的 
     * 由线程A、C执行
     * fun2()方法是普通方法 
     * 由线程B、D执行
     * 重写run()方法
     * 使4个线程分别能够执行fun1()和fun2()
     */
    private int count;

    public Test() {
        count = 0;
    }

    public void fun1() {
        synchronized (this) {
            for (int i = 0; i < 5; i++) {
                System.out.println(Thread.currentThread().getName() + "：" + (count++));
            }
        }
    }

    public void fun2() {

        for (int i = 0; i < 5; i++) {
            System.out.println(Thread.currentThread().getName() + "抢到了CPU！");
        }
    }

    public void run() {
        String threadName = Thread.currentThread().getName();
        if (threadName.equals("A")) {
            fun1();
        } else if (threadName.equals("B")) {
            fun2();
        } else if (threadName.equals("C")) {
            fun1();
        } else if (threadName.equals("D")) {
            fun2();
        }
    }
}

public class Demo3 {
    public static void main(String arg[]) {
        Test t = new Test();
        Thread thread1 = new Thread(t, "A");
        Thread thread2 = new Thread(t, "B");
        Thread thread3 = new Thread(t, "C");
        Thread thread4 = new Thread(t, "D");
        thread1.start();
        thread2.start();
        thread3.start();
        thread4.start();
    }
}

此时结果如下：

线程B、D执行普通代码块，始终在争抢CPU，线程A、C执行同步代码块，因此是线程A执行完任务代码后，线程C才开始执行；但要注意线程A在执行时也同线程B、D在争抢CPU，这也证明了程序内存在同步代码块以及普通代码块的时候，线程是可以同时访问这些代码块并且互相之间不排斥的。

---

5、修改同步锁

对 Demo3 案例做一下修改

class Test implements Runnable {

    private int count;
    Object obj = new Object();

    public Test() {
        count = 0;
    }

    public void fun1() {
        synchronized (obj) {// 该锁是obj对象
            for (int i = 0; i < 3; i++) {
                System.out.println(Thread.currentThread().getName() + "：" + (count++));
            }
        }
    }

    public synchronized void fun2() {// 该锁是this对象

        for (int i = 0; i < 3; i++) {
            System.out.println(Thread.currentThread().getName() + "抢到了CPU！");
        }
    }

    public void run() {
        String threadName = Thread.currentThread().getName();
        if (threadName.equals("A")) {
            fun1();
        } else if (threadName.equals("B")) {
            fun2();
        }
    }
}

public class Demo4 {
    public static void main(String arg[]) {
        Test t = new Test();
        Thread thread1 = new Thread(t, "A");
        Thread thread2 = new Thread(t, "B");

        thread1.start();
        thread2.start();

    }
}

此时结果如下：

虽然2个线程传入的是同一个对象t，但在调用方法是，同步代码块的锁是obj对象，同步方法的锁是this对象，因此呈现在结果中，线程A、B依然在争抢CPU。

对上述代码加以修改：

class Test implements Runnable {
    private int count;
    public Test() {
        count = 0;
    }
    public void fun1() {
        synchronized (this) {// 该锁改为this对象
            for (int i = 0; i < 3; i++) {
                System.out.println(Thread.currentThread().getName() + "：" + (count++));
            }
        }
    }
    public synchronized void fun2() {// 该锁依然是this对象
        for (int i = 0; i < 3; i++) {
            System.out.println(Thread.currentThread().getName() + "抢到了CPU！");
        }
    }
    public void run() {
        String threadName = Thread.currentThread().getName();
        if (threadName.equals("A")) {
            fun1();
        } else if (threadName.equals("B")) {
            fun2();
        }
    }
}

此时结果如下：

当两个线程调用的方法的锁都是this对象时，线程A、B受到同步锁的影响，只有一个线程执行完任务代码之后，另一个线程才开始执行。

提示：
当有一个明确的对象作为锁时，就采用以下类似的代码：

public void fun(){
   // obj 锁定的对象
   synchronized(obj){
      // 要完成的任务
   }
}

当没有明确的对象作为锁，只是想让一段代码同步时，可以创建一个特殊的对象来充当锁：

class Test implements Runnable
{
   Object obj = new Object();  // 特殊的对象
   public void fun() {
      synchronized(obj) {
         // 要完成的任务
      }
   }
}

---

6、单例设计模式中懒汉式并发访问的安全问题

有关单例设计模式的内容，请看单例设计模式。

class Single {
    private Single() {
    }

    private static Single s;

    public static Single getInstance() {
        if (s == null) {
            /*
             * 之所以说懒汉式并发访问存在安全问题
             * 原因就在这里
             * 假设当线程t1抢占到CPU
             * 执行到该注释位置时，CPU被t2抢走
             * 当t2执行到该注释位置时
             * CPU再次被t1抢回来
             * 那么此时t1已经判断过s为空
             * 会直接执行下一句代码创建对象
             * 当t2也抢到CPU
             * 也已经判断过s为空
             * 同样会直接执行下一句代码创建对象
             * 那么此时就会创建2个对象
             * 无法保证单例
             */
            s = new Single();
        }
        return s;
    }
}

class Test implements Runnable {
    public void run(){
        Single s = Single.getInstance();
    }
}

public class Demo5 {

    public static void main(String[] args) {

        Test t = new Test();
        Thread t1 = new Thread(t);
        Thread t2 = new Thread(t);
        t1.start();
        t2.start();

    }
}

避免懒汉式出现该问题的方法之一，就是结合使用synchronized代码块，修改代码如下：

class Single {
    private Single() {
    }

    private static Single s;

    public static Single getInstance() {
        /*
         * 使用synchronized代码块包围创建对象部分
         * 此时的锁是Single.class
         * 由于判断锁需要消耗更多性能
         * 因此添加if判断
         * 可保证线程过多时
         * 从第三个线程开始
         * 先判断对象是否存在
         * 而不是直接判断锁
         * 从而提高性能
         */
        if (s == null) {
            synchronized (Single.class) {
                if (s == null) {
                    s = new Single();
                }

            }
        }
        return s;
    }

}

---

7、总结

1. 当synchronized关键字作用的对象是非静态的，那么它取得的锁是对象；当synchronized作用的对象是静态的，那么它取得的锁是该类的字节码文件，该类的所有对象用同一把锁。

2. 每个对象只有一个锁（lock）与之相关联，哪个线程获得这个锁，该线程就可以运行它所控制的那段代码，此时其他线程无法访问。

3. 实现同步是要很大的系统开销作为代价的，甚至可能造成死锁，所以尽量避免无谓的同步控制。

注意：
随着JKD版本的更新，在1.5版本之后出现比synchronized更加强大的实现同步锁的方法，详情参考使用Lock接口与Condition接口实现生产者与消费者。

---

版权声明：欢迎转载，欢迎扩散，但转载时请标明作者以及原文出处，谢谢合作！             ↓↓↓