Java 多线程 之 线程的同步机制

一、线程的安全问题

　　1、问题的发现

　　　　当有多个线程同时运行，而这些线程可能会同时运行这段代码。程序每次运行结果和单线程运行的结果是一样的，而且其他的变量的值也和预期的是一样的，这就是线程安全的。

　　　　下面通过一个案例来演示线程的安全问题。

　　　　模拟电影票买票的过程，其中，一共有100张票。下面来模拟电影票的售票窗口，实现多个窗口同时卖票，采用线程对象来模拟，通过实现 Runnable 接口子类来模拟。

　　　　示例：

public class WindowTest1 {
    public static void main(String[] args) {
        Window w = new Window();

        Thread t1 = new Thread(w, "窗口1");
        Thread t2 = new Thread(w, "窗口2");
        Thread t3 = new Thread(w, "窗口3");

        //同时卖票
        t1.start();
        t2.start();
        t3.start();
    }
}

class Window implements Runnable {

    private int ticket = 100;

    @Override
    public void run() {
        
        while (true) {
            //有票，可以出售
            if (ticket > 0) {

                //出票操作，使用 sleep 模拟一下出票时间
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                //获取当前线程对象的名字
                System.out.println(Thread.currentThread().getName() + ":卖票，票号为：" + ticket);


                ticket--;
            } else {
                break;
            }
        }
    }
}

 

　　运行结果，发现会有这样的现象发生：

　　（1）错票

　　　　

　　（2）重票

　　　　

 　　　　在运行结果中可以看到会有两个问题发生：

　　　　　　① 相同的票数，比如100这张票被卖了两次；

　　　　　　② 不存在的票，比如 0 和 -1 票，是不存在的；

 

　　2、分析问题

　　　　针对于上面的售票现象，为什么会出现这样的情况呢？

　　　　当只有一个窗口售票或多个窗口分别出售自己的票是没有问题的。但是当三个窗口，同时访问共享的资源，就会导致线程不同步，这种问题称为 线程不安全。

 

　　线程安全问题的产生的原理：

　　　　　　可以发现多个线程执行的不确定性引起执行结果的不稳定；

　　　　　　多个线程对公共的数据处理，会造成操作的不完整性，会破坏数据。

　　　　注意：线程安全问题都是由全局变量及静态变量引起的。若每个线程中对全局变量，静态变量只有读操作，而无写操作，一般来说，这个全局变量是线程安全的；若有多个线程同时执行写操作，一般都需要考虑线程同步，否则的话就可能影响线程安全。

　　

　　3、问题的总结

　　　　问题出现的原因：当多条语句在操作同一个线程共享数据时，一个线程对多条语句只执行了一部分，还没有执行完，另一个线程参与进来执行。导致共享数据的错误。

　　　　如何解决：对多条操作共享数据的语句，只能让一个线程都执行完，在执行过程中，其他线程不可以参与执行。

　　　　　　　　　当一个线程a在操作ticket的时候，其他线程不能参与进来。直到线程a操作完ticket时，其他线程才可以开始操作ticket。这种情况即使线程a出现了阻塞，也不能被改变。

二、同步机制

　　Java 对于多线程的安全问题提供了专业的解决方式：同步机制

　　针对上面的售票案例简单描述一下同步机制：

当窗口1线程进入操作的时候，窗口2和窗口3线程只能在外面等着，窗口1操作结束，窗口1、窗口2和窗口3才有机会进入代码去执行。
 也就是说某个线程修改共享资源的时候，其他线程不能修改该资源，等待修改完毕之后，才能去抢夺CPU资源，完成对应的操作，保证了数据的同步性，解决了线程不安全的现象。

 

　　同步方式的分析：

　　　　1、同步的方式，解决了线程的安全问题（好处）

　　　　2、操作同步代码时，只能有一个线程参与，其他线程等待。相当于是一个单线程的过程，效率低。（局限性）

　　同步的注意项：

　　　　（1）操作共享数据的代码，即为需要被同步的代码加锁；

　　　　　　  不能包含的代码少了（同步将不起作用），也不能包含多了（可能造成死锁或与逻辑混乱）

　　　　（2）共享数据：多个线程共同操作的变量。例如：ticket就是共享数据。

　　　　（3）同步监视器，俗称：锁。任何一个类的对象，都可以充当锁。

　　　　　　  要求：多个线程必须要共用同一把锁。

　　

三、方式一：同步代码块

　　1、语法格式

synchronized (对象){
    // 需要被同步的代码 / 可能会出现线程安全问题的代码（访问共享数据的代码）
}

　　

　　2、实现方式使用同步代码块

　　　　代码示例：

public class WindowTest1 {
    public static void main(String[] args) {
        Window w = new Window();

        Thread t1 = new Thread(w, "窗口1");
        Thread t2 = new Thread(w, "窗口2");
        Thread t3 = new Thread(w, "窗口3");

        //同时卖票
        t1.start();
        t2.start();
        t3.start();
    }
}

class Window implements Runnable {

    private int ticket = 100;
    //创建一个 同步监视器，锁对象
    private Object obj = new Object();

    @Override
    public void run() {
        
        while (true) {
            synchronized (obj) {  //使用 synchronized 给操作共享数据的地方加锁
                //有票，可以出售
                if (ticket > 0) {

                    //出票操作，使用 sleep 模拟一下出票时间
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    //获取当前线程对象的名字
                    System.out.println(Thread.currentThread().getName() + ":卖票，票号为：" + ticket);


                    ticket--;
                } else {
                    break;
                }
            }
        }
    }
}

 

　　如果加锁都需要创建一个对象，我们可以改进一下：

public class WindowTest1 {
    public static void main(String[] args) {
        Window w = new Window();

        Thread t1 = new Thread(w, "窗口1");
        Thread t2 = new Thread(w, "窗口2");
        Thread t3 = new Thread(w, "窗口3");

        //同时卖票
        t1.start();
        t2.start();
        t3.start();
    }
}

class Window implements Runnable {

    private int ticket = 100;

    @Override
    public void run() {
        
        while (true) {
            synchronized (this) {  //方式二：此时的this:唯一的Window1的对象
                //有票，可以出售
                if (ticket > 0) {

                    //出票操作，使用 sleep 模拟一下出票时间
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    //获取当前线程对象的名字
                    System.out.println(Thread.currentThread().getName() + ":卖票，票号为：" + ticket);


                    ticket--;
                } else {
                    break;
                }
            }
        }
    }
}

 

　　注意：这里的 this 指的就是当前的 Window 对象，因为在main方法中多个 Thread 共用了同一个 Window 对象，所以这里的 this 是公共的锁。

　　3、继承方式使用同步代码块

public class WindowTest2 {
    public static void main(String[] args) {
        Window2 t1 = new Window2();
        Window2 t2 = new Window2();
        Window2 t3 = new Window2();

        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");

        t1.start();
        t2.start();
        t3.start();
    }
}

class Window2 extends Thread {
    private static int ticket = 100;
    private static Object obj = new Object();

    @Override
    public void run() {

        while (true) {
            synchronized (obj) {
                if (ticket > 0) {

                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }

                    System.out.println(getName() + "：卖票，票号为：" + ticket);
                    ticket--;
                } else {
                    break;
                }
            }
        }
    }
}

 

　　对于继承的方式，如果我们也想避免创建的繁琐，可以这样写：

public class WindowTest2 {
    public static void main(String[] args) {
        Window2 t1 = new Window2();
        Window2 t2 = new Window2();
        Window2 t3 = new Window2();

        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");

        t1.start();
        t2.start();
        t3.start();
    }
}

class Window2 extends Thread {
    private static int ticket = 100;

    @Override
    public void run() {

        while (true) {
            synchronized (Window2.class) {  //方式2
                if (ticket > 0) {

                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }

                    System.out.println(getName() + "：卖票，票号为：" + ticket);
                    ticket--;
                } else {
                    break;
                }
            }
        }
    }
}

 

　　注意：这里是不能使用 this 的，因为在 main 中创建了多个 Window2对象，它们各不一样。但是我们可以使用当前类的对象，全局唯一的类对象来充当锁。因为类对象只会加载一次，是全局唯一的。

　　4、小结

　　　　（1）操作共享数据的代码，即为需要被同步的代码加锁；

　　　　　　  不能包含的代码少了（同步将不起作用），也不能包含多了（可能造成死锁或与逻辑混乱）

　　　　（2）共享数据：多个线程共同操作的变量。例如：ticket就是共享数据。

　　　　（3）同步监视器，俗称：锁。任何一个类的对象，都可以充当锁。

　　　　　　  要求：多个线程必须要共用同一把锁。

　　　　  注意：（具体情况还要具体分析！）

　　　　　　① 在实现Runnable接口创建多线程的方式中，我们可以考虑使用this充当同步监视器。

　　　　　　② 在继承Thread类创建多线程的方式中，慎用 this 充当同步监视器，考虑使用当前类充当同步监视器。

　　　　

四、方式二：同步方法

　　1、语法格式

public static synchronized void show (String name){
   可能会产生线程安全问题的代码 / 可能会出现线程安全问题的代码(访问了共享数据的代码)
}

　　　　synchronized还可以放在方法声明中，表示整个方法为同步方法。

　　　如果操作共享数据的代码完整的声明在一个方法中，我们不妨将此方法声明同步的。

　　2、实现方式使用同步方法

　　　　代码示例：

public class WindowTest3 {
    public static void main(String[] args) {
        Window3 w = new Window3();

        Thread t1 = new Thread(w);
        Thread t2 = new Thread(w);
        Thread t3 = new Thread(w);

        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");

        t1.start();
        t2.start();
        t3.start();
    }
}

class Window3 implements Runnable {
    private int ticket = 100;


    @Override
    public void run() {
        while (true) {
            show();
        }
    }

    private synchronized void show() {  //同步监视器：this
        if (ticket > 0) {

            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            System.out.println(Thread.currentThread().getName() + ":卖票，票号为：" + ticket);

            ticket--;
        }
    }
}

 

　　　　注意：这里的锁对象是 this，因为在 main 方法中还是共用了同一个 Window3 对象，这里的 this 就是此对象，可以公共的锁对象。如果在 main 中创建了多个 Window3 对象并传递给 Thread来启动，这样并不可以保证同步哦！

　　3、继承方式使用同步方法

　　　　代码示例：

public class WindowTest4 {
    public static void main(String[] args) {
        Window4 t1 = new Window4();
        Window4 t2 = new Window4();
        Window4 t3 = new Window4();


        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");

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

    }
}

class Window4 extends Thread {
    private static int ticket = 100;

    @Override
    public void run() {
        while (true) {
            show();
        }
    }

    private static synchronized void show() {  //同步监视器：Window4.class
        if (ticket > 0) {

            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            System.out.println(Thread.currentThread().getName() + "：卖票，票号为：" + ticket);
            ticket--;
        }
    }
}

 

　　　　注意：在继承中这样使用的锁对象就是 Window4.class，当前的类对象。

　　　　切记不能写成这样

//private synchronized void show(){ //同步监视器：t1,t2,t3。此种解决方式是错误的

　　　　 这样他们的锁对象就不再是类对象，而是以每个实例对象为锁的，并不是公共的锁，不能保证同步。

　　4、小结

　　　　（1）同步方法仍然涉及到同步监视器，只是不需要我们显式的声明。

　　　　（2）非静态的同步方法，同步监视器是实现类对象：this；

　　　　　　  静态的同步方法，同步监视器是当前类对象：当前类本身

　　

五、同步的总结

　　1、分析同步原理

　　　　

 

　　2、同步机制中的锁

　　　　（1）同步锁机制

　　　　（2）synchronized 的锁是什么？

　　　　　　① 任意对象都可以作为同步锁，所有对象都自动含有单一的锁（监视器）。

　　　　　　② 同步方法的锁：静态方法（类名.class）、非静态方法（this）

　　　　　　③ 同步代码块：自己指定，很多时候也是指定为 this 或 类名.class

　　　　（3）注意

　　　　　　① 必须确保使用同一个资源的多个线程共用一把锁，这个非常重要，否则无法保证共享资源的安全；

　　　　　　② 一个线程类中的所有静态方法共用一把锁（类名.class），所有非静态方法共用同一把锁（this），同步代码块（指定需谨慎）

　　3、同步的范围

　　　　（1）如何找问题，即代码是否存在线程安全？（重要）

　　　　　　① 明确哪些代码是多线程运行的代码；

　　　　　　② 明确多个线程是否有共享数据；

　　　　　　③ 明确多线程运行代码中是否有多条语句操作共享数据；

　　　　（2）如果解决？（重要）

　　　　　　① 对多条操作共享数据的语句，只能让一个线程都执行完，在执行过程中，其他线程不可以参与执行；

　　　　　　② 即所有操作共享数据的这些语句都要放在同步范围中；

　　　　（3）切记

　　　　　　① 范围太小：没锁住所有有安全问题的代码；

　　　　　　② 范围太大：没发挥多线程的功能；

　　4、释放锁的操作

　　　　（1）当前线程的同步方法、同步代码块执行结束；

　　　　（2）当前线程在同步代码块、同步方法中遇到 break、return 终止了该代码块、该方法的继续执行；

　　　　（3）当前线程在同步代码块、同步方法中出现了未处理的 Error 或 Exception，导致异常结束；

　　　　（4）当前线程在同步代码块、同步方法中执行了线程对象的 wait() 方法，当前线程暂停，并释放锁。

　　5、不会释放锁的操作

　　　　（1）线程执行同步代码块或同步方式时，程序调用 Thread.sleep()、Thread.yield() 方法暂停当前线程的执行；

　　　　（2）线程执行同步代码块时，其他线程调用了该线程的 suspend() 方法将该线程挂起，该线程不会释放锁（不同监视器）；

　　　　　　 应尽量避免使用 suspend() 和 resume() 来控制线程；

 

六、Lock 锁——JDK5.0 新增锁

　　1、Lock 锁

　　　　（1）从 JDK5.0 开始，Java 提供了更强大的线程同步机制——通过显示定义同步锁对象来实现同步，同步锁使用 Lock 对象充当；

　　　　（2）java.util.concurrent.locks.Lock 接口是控制多个线程对共享资源进行访问的工具。

　　　　　　  锁提供了对共享资源的独占访问，每次只能有一个线程对 Lock 对象加锁，线程开始访问共享资源之前应先获得 Lock 对象。

　　　　（3）ReentrantLock 类实现了 Lock，它拥有与 synchronized 相同的并发性和内存语义，在实现线程安全的控制中，比较常用的是 ReentrantLock，可以显式加锁、释放锁。

　　2、语法

class A{
    private final ReentrantLock lock = new ReenTrantLock();
        public void m(){
            lock.lock();
            try{
                //保证线程安全的代码;
            }
            finally{
                lock.unlock();
            }
        }
}        

　　　　注意：如果同步代码有异常，要将 unlock( )写入finally语句块

　　3、实现方式使用 Lock 锁

　　　　使用步骤：

　　　　　　① 在成员位置创建一个ReentrantLock对象（Lock接口的一个实现类）

　　　　　　② 在可能会出现安全问题的代码前调用Lock接口中的方法lock获取锁

　　　　　　③ 在可能会出现安全问题的代码后调用Lock接口中的方法unlock释放锁

　　　　示例：

public class WindowTest5 {
    public static void main(String[] args) {
        Window5 w = new Window5();

        Thread t1 = new Thread(w);
        Thread t2 = new Thread(w);
        Thread t3 = new Thread(w);

        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");

        t1.start();
        t2.start();
        t3.start();
    }
}

class Window5 implements Runnable {

    private int ticket = 100;
    //1.实例化ReentrantLock
    private ReentrantLock lock = new ReentrantLock();

    @Override
    public void run() {
        while (true) {
            try {
                //2.调用锁定方法 lock()
                lock.lock();

                if(ticket > 0){

                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }

                    System.out.println(Thread.currentThread().getName() + "：售票，票号为：" + ticket);
                    ticket--;
                }else{
                    break;
                }
            } finally {
                //3.调用解锁方法：unlock()，无论程序是否异常,都会把锁释放
                lock.unlock();
            }
        }
    }
}

 

　　4、继承方式使用 Lock 锁

　　　　代码示例：

public class WindowTest6 {
    public static void main(String[] args) {
        Window6 w1 = new Window6();
        Window6 w2 = new Window6();
        Window6 w3 = new Window6();

        w1.setName("窗口一");
        w2.setName("窗口二");
        w3.setName("窗口三");

        w1.start();
        w2.start();
        w3.start();
    }
}

class Window6 extends Thread {

    private static int ticket = 100;
    //1.实例化ReentrantLock
    private static ReentrantLock lock = new ReentrantLock();

    @Override
    public void run() {
        while (true) {
            try {
                //2.调用锁定方法 lock()
                lock.lock();

                if(ticket > 0){

                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }

                    System.out.println(Thread.currentThread().getName() + "：售票，票号为：" + ticket);
                    ticket--;
                }else{
                    break;
                }
            } finally {
                //3.调用解锁方法：unlock()
                lock.unlock();
            }
        }
    }
}

 

　　5、synchronized 与 Lock 的对比

　　　　（1）Lock 是显式锁（手动开启和关闭锁，别忘记关闭锁），synchronized 是隐式锁，出了作用自动释放；

　　　　（2）Lock 只有代码块锁，synchronized 有代码块锁和方法所；

　　　　（3）使用 Lock 锁，JVM 将花费较少的时间来调度线程，性能更好。并且具有更好的扩展性（提供更多的子类）

　　　　优先使用顺序：

Lock ——>同步代码块（已经进入了方法体，分配了相应资源）——>同步方法（在方法体之外）

 

七、线程的死锁问题

　　1、死锁

　　　　（1）不同的线程分别占用对方需要的同步资源不放弃，都在等待对方放弃自己需要的同步资源，就形成了线程的死锁；

　　　　（2）出现死锁后，不会出现异常，不会出现提示，只是所有的线程都处于阻塞状态，无法继续；

　　　　（3）死锁是指两个或两个以上的线程在执行过程中，由于竞争资源或者由于彼此通信而造成的一种阻塞的现象，若无外力作用，它们都将无法推进下去。

　　2、死锁的必要条件

　　　　死锁的发生也必须具备一定的条件，死锁的发生必须具备以下四个必要条件

　　　　1）互斥条件：指进程对所分配到的资源进行排它性使用，即在一段时间内某资源只由一个进程占用。如果此时还有其它进程请求资源，则请求者只能等待，直至占有资源的进程用毕释放。

　　　　2）请求和保持条件：指进程已经保持至少一个资源，但又提出了新的资源请求，而该资源已被其它进程占有，此时请求进程阻塞，但又对自己已获得的其它资源保持不放。

　　　　3）不剥夺条件：指进程已获得的资源，在未使用完之前，不能被剥夺，只能在使用完时由自己释放。

　　　　4）环路等待条件：指在发生死锁时，必然存在一个进程——资源的环形链，即进程集合{P0，P1，P2，···，Pn}中的P0正在等待一个P1占用的资源；P1正在等待P2占用的资源，……，Pn正在等待已被P0占用的资源。

　　3、解决方法

　　　　（1）专门的算法、原则；

　　　　（2）尽量减少同步资源的定义；

　　　　（3）尽量避免嵌套同步

　　4、示例

　　　　示例一：

//死锁的演示
class A {
    public synchronized void foo(B b) { //同步监视器：A类的对象：a
        System.out.println("当前线程名: " + Thread.currentThread().getName()
                + " 进入了A实例的foo方法"); // ①
        try {
            Thread.sleep(200);
        } catch (InterruptedException ex) {
            ex.printStackTrace();
        }
        System.out.println("当前线程名: " + Thread.currentThread().getName()
                + " 企图调用B实例的last方法"); // ③
        b.last();
    }

    public synchronized void last() {//同步监视器：A类的对象：a
        System.out.println("进入了A类的last方法内部");
    }
}

class B {
    public synchronized void bar(A a) {//同步监视器：b
        System.out.println("当前线程名: " + Thread.currentThread().getName()
                + " 进入了B实例的bar方法"); // ②
        try {
            Thread.sleep(200);
        } catch (InterruptedException ex) {
            ex.printStackTrace();
        }
        System.out.println("当前线程名: " + Thread.currentThread().getName()
                + " 企图调用A实例的last方法"); // ④
        a.last();
    }

    public synchronized void last() {//同步监视器：b
        System.out.println("进入了B类的last方法内部");
    }
}

public class DeadLock1 implements Runnable {
    A a = new A();
    B b = new B();

    public void init() {
        Thread.currentThread().setName("主线程");
        // 调用a对象的foo方法
        a.foo(b);
        System.out.println("进入了主线程之后");
    }

    public void run() {
        Thread.currentThread().setName("副线程");
        // 调用b对象的bar方法
        b.bar(a);
        System.out.println("进入了副线程之后");
    }

    public static void main(String[] args) {
        DeadLock1 dl = new DeadLock1();
        new Thread(dl).start();


        dl.init();
    }
}

 

　　　　示例二：

public class DeadLock2 {
    public static void main(String[] args) {

        StringBuffer s1 = new StringBuffer();
        StringBuffer s2 = new StringBuffer();


        new Thread() {
            @Override
            public void run() {

                synchronized (s1) {

                    s1.append("a");
                    s2.append("1");

                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }


                    synchronized (s2) {
                        s1.append("b");
                        s2.append("2");

                        System.out.println(s1);
                        System.out.println(s2);
                    }
                }
            }
        }.start();


        new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized (s2) {

                    s1.append("c");
                    s2.append("3");

                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }

                    synchronized (s1) {
                        s1.append("d");
                        s2.append("4");

                        System.out.println(s1);
                        System.out.println(s2);
                    }
                }
            }
        }).start();
    }

}