Java基础进阶 JDK1.5后的同步解决和线程面试题

1、JDK1.5后的同步解决(掌握)

在多生产和多消费的程序中，为了防止死锁，我们使用notifyAll()方法，这样保证唤醒的所有线程中肯定有生产者线程，还会有消费者线程，即使本方唤醒了本方，由于使用的while循环判断有没有商品（手机），唤醒的线程还会继续去判断。但是由于本方唤醒本方，本身就没有意义。只有本方唤醒对方，这样才能和谐的进行下去。

而在jdk5之前，java没有提供可以让本方唤醒对方的技术。而在JDK5中提供了对同步锁的升级，以及提供了等待和唤醒的升级。这样就可以保证在唤醒的时候，不再唤醒自己的一方，而是唤醒对方。

锁的升级：
在JDK5之前，锁的获取和释放都是隐式的，看不见。也就说我们并没有直接看到在哪里加上了锁，在哪里释放了锁。到了JDK5的时候，java中提供了一个Lock接口，在这个接口中定义了锁的释放和获取的方法，后期程序中需要使用同步，这时可以使用Lock接口的实现类显示的完成锁的获取和释放的动作。

1.1、认识Lock

1.png

说明：
1）属于java.util.concurrent.locks包下的；
2）JDK5提供的Lock接口比JDK5之前的同步更好使用，更加灵活。Lock接口代替JDK5之前的同步代码块。

Lock接口的函数如下所示：

2.png

注意：在使用Lock锁对象时，需要手动的书写代码用来：获取锁、释放锁
（在同步代码块中不需要手动的书写获取锁、释放锁的代码。但是，同步代码块在执行时底层还是会获取锁、释放锁）

由于Lock属于接口，不能创建对象，所以我们可以使用它的子类ReentrantLock来创建对象并使用Lock接口中的函数。

3.png

ReentrantLock类的构造函数如下所示：

4.png

1.2、使用Lock演示卖票案例

需求：使用Lock实现线程安全的卖票。
分析和步骤：
1）定义一个卖票的任务类SellTicketTask 类并实现Runnable接口；
2）在任务类中定义一个成员变量tickets保存票数100；
3）定义一把锁Lock的对象l；
4）在run函数中模拟卖票，if语句的上面使用锁对象l调用lock()函数获取锁，等待if语句结束之后，使用锁对象l调用unlock()函数释放锁；
5）定义测试类SellTicketDemo，在这个类中分别创建任务类的对象和线程类的对象，并使用线程类的对象调用start()函数来启动线程；

/*
 * 需求：使用Lock实现线程安全的卖票。
 * Lock是接口，只能通过他的子类ReentrantLock创建对象
 * 构造函数 ReentrantLock()  创建一个 ReentrantLock 的实例。
 *  void lock() 获取锁。 
 *  void unlock() 试图释放此锁。 
 */
//定义一个任务类用来卖票
class SellTicketTask implements Runnable
{
    //定义100张票
    private static int tickets=100;
    //创建对象作为任意一把锁
//  private Object obj=new Object();
    //定义一把锁
    Lock l=new ReentrantLock();
    //模拟卖票
    public void run() {
        /*while(true)
        {
            synchronized (obj) {
                if(tickets>0)
                {
                    System.out.println(Thread.currentThread().getName()+"出票："+tickets--);
                }
            }
        }*/
        //使用Lock锁替换synchronized
        while(true)
        {
                //获取锁
                l.lock();
                if(tickets>0)
                {
                    try {Thread.sleep(1);} catch (InterruptedException e) {}
                    System.out.println(Thread.currentThread().getName()+"出票："+tickets--);
                }
                //释放锁
                l.unlock();
        }
    }
}
public class SellTicketDemo {
    public static void main(String[] args) {
        // 创建任务类对象
        SellTicketTask stt = new SellTicketTask();
        //创建线程对象
        Thread t1 = new Thread(stt,"窗口1");
        Thread t2 = new Thread(stt,"窗口2");
        Thread t3 = new Thread(stt,"窗口3");
        Thread t4 = new Thread(stt,"窗口4");
        //启动线程
        t1.start();
        t2.start();
        t3.start();
        t4.start();
    }
}

1.3、认识Condition

在以前，用一把锁来同时控制生产和消费线程等待唤醒的。使用wait()和notify()机制，每次唤醒线程都是随机的，因此给我们带来了一些奇怪的BUG。(例如，程序卡主)。在JDK5中，提供了Condition对象控制线程状态，可以有针对性的控制线程的等待和唤醒。

5.png

说明：
1）在JDK5之前，等待和唤醒必须和锁绑定在一起。在JDK5之后把锁和等待唤醒抽离到2个不同的接口中；
2）Lock锁接口代替了synchronized同步代码块的书写，专门负责同步的锁；
3）Condition接口代替了同步代码块中锁对象上的等待唤醒功能，专门负责线程的等待和唤醒；

Condition接口中的主要函数如下所示：

6.png

Condition是一个接口，不能new对象，所以要获取Condition接口的对象，使用Lock接口中的newCondition()方法：

7.png

Lock接口中的newCondition()方法：![image](http://upload-

8.png

说明：

一个Lock锁上，可以获取多个Condition对象，就是可以使用Lock锁对象多次调用newCondition()方法获取多个Condition对象。

并且每个Condition可以控制不同的线程。

比如：我创建两个Condition对象，
一个Condition专门控制生产线程，另一个专门控制消费的线程。

这样就可以达到我们想要的针对性的控制线程的等待和唤醒，想要哪个线程等待或者唤醒都可以实现。

1.4、改造单生产和单消费代码

需求：改造之前书写过的单线程生产和单线程的消费代码。只需要修改生产车间PhoneFactory 类中的代码即可。

分析和步骤：
1）代码和之前都一样，只需添加几行代码即可；
2）定义锁Lock 对象l，同时使用锁对象l调用newCondition()函数并创建生产者和消费者的Condition类的对象，分别为pro_con和con_con;
3）首先分别将原来的produce()和get()函数的同步synchronized去掉，换成lock()和unlock()函数；
4）在produce()函数中使用pro_con对象调用await()函数让生产线程等待，使用con_con对象调用signal()函数唤醒消费者线程；
5）在get()函数中使用con_con对象调用await()函数让消费线程等待，使用pro_con对象调用signal()函数唤醒生产者线程；

/*
 * 这是生产手机的车间，其实是一个小作坊
 * 每次生产一部手机，并且每次消费一部分手机
 * 正确的思路：
 *  对于生产线程：每次生产之前，先判断是否有手机，如果有手机，就不生产，则等待。如果没有手机，则生产，生产完成唤醒消费者来消费。
 *  对于消费线程：每次消费之前，先判断是否有手机，如果没有手机，就不消费，则等待。如果有手机，则消费，消费完成唤醒生产者来生产。
 * void wait()  让线程等待
 * void notify()  唤醒某个线程
 * 
 * 使用Lock和Condition改造单生产和单消费的代码
 */
public class PhoneFactory {
    //定义成员变量存储手机
    private String name;//手机名字
    private double price;//手机价格
    //定义一个变量用来决定生产哪部手机
    private int i=0;
    //定义一个变量作为标记，用来标记是否有手机
    private boolean hasPhone=false;//false表示没有手机,true表示有手机
    //定义锁对象
    private Lock l=new ReentrantLock();
    //定义生产者的Condition对象
    private Condition pro_con= l.newCondition();
    //定义消费者的Condition对象
    private Condition con_con=l.newCondition();
    //定义一个函数用来生产手机
    //给函数加同步，线程的锁是this
    public /*synchronized*/ void produce()
    {
        //获取锁
        l.lock();
        //先判断是否有手机
        while(hasPhone)
        {
            //说明有手机，不生产，线程等待
//          try {this.wait();} catch (InterruptedException e) {}
            try {pro_con.await();} catch (InterruptedException e) {}
        }
        //线程走到这里说明没有手机
        //生产手机
        if(i%2 == 0)
        {
            this.name="Iphone6 Plus";
            this.price=6888.00;
        }else
        {
            this.name="华为";
            this.price=799.00;
        }
        //有手机了，修改标记
        this.hasPhone=true;
        //唤醒
//      this.notify();
        //唤醒所有的线程
//      this.notifyAll();
        //唤醒消费者
        con_con.signal();
        i++;
        //释放锁
        l.unlock();
    }
    //定义一个函数让外界来获取手机
    ////给函数加同步，线程的锁是this
    public /*synchronized*/ void get()
    {
        //获取锁
        l.lock();
        //判断是否有手机
        while(!hasPhone)
        {
            //没有手机，就不消费，则等待
//          try {this.wait();} catch (InterruptedException e) {}
            try {con_con.await();} catch (InterruptedException e) {}
        }
        //说明有手机，消费手机
        System.out.println("消费了:"+name+"....."+price);
        //更改手机标记，消费完了，手机肯定没了
        this.hasPhone=false;
        //消费完成唤醒生产者来生产
//      this.notify();
        //唤醒所有的线程
//      this.notifyAll();
        //唤醒生产线程
        pro_con.signal();
        //释放锁
        l.unlock();
    }
}

问题：通过上述代码我们发现定义生产者的Condition对象和定义消费者的Condition对象的代码除了变量名pro_con和con_con有区别之外，剩下的几乎没有区别(这里的两个对象效果是一样的，两个变量中的地址值肯定是不一样的)，那么为什么pro_con.signal()就是唤醒生产者，而con_con.signal()唤醒的就是消费者呢？为什么不能说pro_con.signal()是唤醒消费者，con_con.signal()是唤醒生产者呢？

答：
Condition对象只能唤醒自己等待的线程。换句话说不能唤醒别人等待的线程。
举例：上述produce()函数中，当执行pro_con.await()函数时，生产线程等待，那么对于Condition类的对象pro_con调用signal()函数时只能唤醒生产线程之类的线程。不会唤醒消费线程。
signal()函数唤醒一个随机线程，并且是自己等待线程中的随机线程。即，指定类型的随机线程。

举例：比如有多个生产者或者多个消费者时，假设调用signal()函数唤醒生产者线程，那么就会在多个生产者线程中随机唤醒某个生产者线程，并不是指定的具体某个生产者线程，但是一定是生产者线程，不会是消费者线程。

1.5、改造多生产和多消费代码

需求：改造之前书写过的多线程生产和多线程的消费代码。只需要修改生产车间PhoneFactory 类中的代码即可。

代码和上述单线程代码一致。

代码如下所示：

/*
 * 这是生产手机的车间，其实是一个小作坊
 * 每次生产一部手机，并且每次消费一部分手机
 * 正确的思路：
 *  对于生产线程：每次生产之前，先判断是否有手机，如果有手机，就不生产，则等待。如果没有手机，则生产，生产完成唤醒消费者来消费。
 *  对于消费线程：每次消费之前，先判断是否有手机，如果没有手机，就不消费，则等待。如果有手机，则消费，消费完成唤醒生产者来生产。
 * void wait()  让线程等待
 * void notify()  唤醒某个线程
 * 
 * 使用Lock和Condition改造单生产和单消费的代码
 */
public class PhoneFactory {
    //定义成员变量存储手机
    private String name;//手机名字
    private double price;//手机价格
    //定义一个变量用来决定生产哪部手机
    private int i=0;
    //定义一个变量作为标记，用来标记是否有手机
    private boolean hasPhone=false;//false表示没有手机,true表示有手机
    //定义锁对象
    private Lock l=new ReentrantLock();
    //定义生产者的Condition对象
    private Condition pro_con= l.newCondition();
    //定义消费者的Condition对象
    private Condition con_con=l.newCondition();
    //定义一个函数用来生产手机
    //给函数加同步，线程的锁是this
    public /*synchronized*/ void produce()
    {
        //获取锁
        l.lock();
        //先判断是否有手机
        while(hasPhone)
        {
            //说明有手机，不生产，线程等待
//          try {this.wait();} catch (InterruptedException e) {}
            try {pro_con.await();} catch (InterruptedException e) {}
        }
        //线程走到这里说明没有手机
        //生产手机
        if(i%2 == 0)
        {
            this.name="Iphone6 Plus";
            this.price=6888.00;
        }else
        {
            this.name="华为";
            this.price=799.00;
        }
        //有手机了，修改标记
        this.hasPhone=true;
        //唤醒
//      this.notify();
        //唤醒所有的线程
//      this.notifyAll();
        //唤醒消费者
        con_con.signal();
        i++;
        //释放锁
        l.unlock();
    }
    //定义一个函数让外界来获取手机
    ////给函数加同步，线程的锁是this
    public /*synchronized*/ void get()
    {
        //获取锁
        l.lock();
        //判断是否有手机
        while(!hasPhone)
        {
            //没有手机，就不消费，则等待
//          try {this.wait();} catch (InterruptedException e) {}
            try {con_con.await();} catch (InterruptedException e) {}
        }
        //说明有手机，消费手机
        System.out.println("消费了:"+name+"....."+price);
        //更改手机标记，消费完了，手机肯定没了
        this.hasPhone=false;
        //消费完成唤醒生产者来生产
//      this.notify();
        //唤醒所有的线程
//      this.notifyAll();
        //唤醒生产线程
        pro_con.signal();
        //释放锁
        l.unlock();
    }
}

说明：
1）

   // 定义锁对象
   private Lock l = new ReentrantLock();
   // 定义生产者的Condition对象
   private Condition pro_con =l.newCondition();
   // 定义消费者的Condition对象
   private Condition con_con =l.newCondition();

上述Lock锁对象和Condition对象必须作为一套一起使用，不能和之前学习的同步synchronized一起混合使用，否则会报异常。

也就是说上述Lock接口必须和Condition一起使用。而同步代码块synchronized还是按照和之前讲解的一样一起使用。

2）这里也可以使用signalAll()函数唤醒同一类线程中的所有线程；

2、多线程面试题

1）多线程有几种实现方案，分别是哪几种?

两种：

     继承Thread：
              A：自定义类，继承Thread
              B：重写run方法
              C：创建线程类对象
              D：启动线程

     实现Runnable：
              A：自定义类，实现Runnable接口
              B：实现run方法
              C：创建任务类对象
              D：创建线程对象，把任务对象作为参数传递
              E：启动线程

2）同步有几种方式，分别是什么?

三种：
A:同步代码块：锁是任意对象，但是必须唯一
B:非静态同步方法：锁是this
C:静态同步方法：锁是当前类的字节码文件对象。类名.class

其实，在JDK1.5提供了新的同步机制：

     Lock
              lock()上锁
              unlock()释放锁

3）run()函数和start()函数的区别?
run：封装线程任务的
start：先启动线程，再执行run方法

4）sleep()和wait()方法的区别

区别：

     A:sleep需要接收时间参数，wait不需要接收时间参数；
     B:sleep可以自然醒，wait必须等待别人唤醒；
     C:sleep不需要同步结合，wait必须与同步结合使用；
     D:sleep不释放锁，而wait会释放锁；

联系：
A:都会导致线程阻塞；
B:都会释放CPU的执行资格和执行权；

5）为什么wait(),notify(),notifyAll()等方法都定义在Object类中?
首先：线程的通信必须由锁来控制
然后，锁对象是任意的，任意对象都能调用的方法，必须定义在Object类中。

6）线程的生命周期图

                                             阻塞（不可运行）
             创建 --->  就绪（可以运行） -->  运行（正在运行） -->死亡

7）死锁产生的原因？
在同步嵌套的情况下，如果多个线程争夺资源，就会出现死锁。

人面猴
序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
沈念sama阅读 194,088评论 5赞 459
死咒
序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
沈念sama阅读 81,715评论 2赞 371
救了他两次的神仙让他今天三更去死
文/潘晓璐我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
开封第一讲书人阅读 141,361评论 0赞 319
道士缉凶录：失踪的卖姜人
文/不坏的土叔我叫张陵，是天一观的道长。经常有香客问我，道长，这世上最难降的妖魔是什么？我笑而不...
开封第一讲书人阅读 52,099评论 1赞 263
港岛之恋（遗憾婚礼）
正文为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
茶点故事阅读 60,987评论 4赞 355
恶毒庶女顶嫁案：这布局不是一般人想出来的
文/花漫我一把揭开白布。她就那样静静地躺着，像睡着了一般。火红的嫁衣衬着肌肤如雪。梳的纹丝不乱的头发上，一...
开封第一讲书人阅读 46,063评论 1赞 272
城市分裂传说
那天，我揣着相机与录音，去河边找鬼。笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。我是一名探鬼主播，决...
沈念sama阅读 36,486评论 3赞 381
双鸳鸯连环套：你想象不到人心有多黑
文/苍兰香墨我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
开封第一讲书人阅读 35,175评论 0赞 253
万荣杀人案实录
序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
沈念sama阅读 39,440评论 1赞 290
护林员之死
正文独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋以下内容为张勋视角年9月15日...
茶点故事阅读 34,518评论 2赞 309
白月光启示录
正文我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
茶点故事阅读 36,305评论 1赞 326
活死人
序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
沈念sama阅读 32,190评论 3赞 312
日本核电站爆炸内幕
正文年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
茶点故事阅读 37,550评论 3赞 298
男人毒药：我在死后第九天来索命
文/蒙蒙一、第九天我趴在偏房一处隐蔽的房顶上张望。院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
开封第一讲书人阅读 28,880评论 0赞 17
一桩弑父案，背后竟有这般阴谋
文/苍兰香墨我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。一阵脚步声响...
开封第一讲书人阅读 30,152评论 1赞 250
情欲美人皮
我被黑心中介骗来泰国打工，没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。一个月前我还...
沈念sama阅读 41,451评论 2赞 341
代替公主和亲
正文我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
茶点故事阅读 40,637评论 2赞 335