【多线程 三】线程同步的几种方式详解

1、问题引入

当多个线程共同访问共享资源的时候，就会发生线程安全的问题，比如如下的程序：

三个窗口同时卖一百张票，但最后出现没有存在的票（0 -1票）
代码：

public class TicketRunnableImpl 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();
                }
                // 当前线程对应的名字
                String name=Thread.currentThread().getName();
                System.out.println(name+"正在卖:"+ticket--);
            }
        }
    }
}

public class Demo01Ticket {
    public static void main(String[] args) {
        TicketRunnableImpl tck=new TicketRunnableImpl();
        Thread thread1= new Thread(tck,"窗口1");
        Thread thread2 = new Thread(tck,"窗口2");
        Thread thread3 = new Thread(tck,"窗口3");
        // 同时卖票
        thread1.start();
        thread2.start();
        thread3.start();
    }
}

以上，最后窗口卖出了不存在的票，就是说最后窗口3已经把最后一个票卖出去了，但是窗口 1， 2还都不知道。还有可能同一个票被卖了两回，这种问题就是线程不安全，当多条语句在操作同一个线程共享数据时，一个线程对多条语句只执行了一部分，还没有执行完，另一个线程参与进来执行，导致共享数据的错误。

解决线程不安全的办法就是线程同步。

2、线程同步

由于多个线程执行的不确定性会引起执行结果的不稳定，所以对多条操作共享数据的语句，只能让一个线程都执行完，在执行过程中，其他线程不可以参与执行。

2.1 同步代码块实现线程同步

格式:

   synchronized(同步锁){ 
       需要同步操作的代码 
   } 

同步锁:

对象的同步锁只是一个概念,可以想象为在对象上标记了一个锁.

1. 锁对象 可以是任意类型。

2. 多个线程对象 要使用同一把锁。

注意:在任何时候,最多允许一个线程拥有同步锁,谁拿到锁就进入代码块,其他的线程只能在外等着

使用同步代码块解决代码：

public class TicketRunnableImpl implements Runnable {
    private int ticket = 100;
    Object lock = new Object();

    @Override
    public void run() {
        while (true) {
            synchronized (lock) {
                if (ticket > 0) {
                    //使用sleep 模拟一下出票时间
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    // 当前线程对应的名字
                    String name = Thread.currentThread().getName();
                    System.out.println(name + "正在卖:" + ticket--);
                }
            }
        }
    }
}

结果，没有在出现0 -1票

2.2 同步代码块实现线程同步

public synchronized void method(){ 
       可能会产生线程安全问题的代码 
   } 

public class TicketRunnableImpl implements Runnable{
    private int ticket = 100;
    Object lock = new Object();
    @Override
    public void run() {
        while (true) {
            sellTicket();
        }
    }

        *   锁对象 是 谁调用这个方法 就是谁
        *   隐含 锁对象 就是  this 
    public  synchronized void sellTicket(){
            if (ticket > 0) {
                //使用sleep 模拟一下出票时间
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                // 当前线程对应的名字
                String name = Thread.currentThread().getName();
                System.out.println(name + "正在卖:" + ticket--);
            }
    }
}

那么此时的同步锁是谁：

对于非static方法,同步锁就是this。
对于static方法,我们使用当前方法所在类的字节码对象(类名.class)。

2.3 Lock 锁实现线程同步

java.util.concurrent.locks.Lock 机制提供了比synchronized代码块和synchronized方法更广泛的锁定操作,同步代码块/同步方法具有的功能Lock都有,除此之外更强大,更体现面向对象。

ReentrantLock 类实现了 Lock ，它拥有与 synchronized 相同的并发性和内存语义，在实现线程安全的控制中，比较常用的是ReentrantLock，可以显式加锁luck()、释放锁unlock()。我们在编码的过程中一定要记得最后要释放锁，所以要避免忘记释放锁（发生死锁），要提前写好下面的模板

public void m(){
	lock.lock();
	try{
		//保证线程安全的代码;
	}
	finally{
		lock.unlock();  
	}
}

对应代码：

   private  int ticket =100;
    Lock lock=new ReentrantLock();
    @Override
    public void run() {
        while (true){
            lock.lock();
            try {
                if (ticket > 0) {
                    //使用sleep 模拟一下出票时间
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    // 当前线程对应的名字
                    String name = Thread.currentThread().getName();
                    System.out.println(name + "正在卖:" + ticket--);
                }
            }finally {
                lock.unlock();
            }
        }
    }

3、synchronized与Lock 的对比

1、二者都可以解决线程安全问题
2、Lock是显示锁（手动开启和关闭锁），synchronized是隐式锁，在执行完相应的代码以后，自动释放锁。
3、Lock只有代码块锁，synchronized有代码块锁和方法锁

4、释放锁的操作

当前线程的同步方法、同步代码块执行结束。

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

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

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

注意：yield() 和 sleep并不会释放锁