为什么会出现线程安全问题？

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

解决线程安全问题的方法

当我们使用多个线程访问同一资源的时候，且多个线程中对资源有写的操作，就容易出现线程安全问题。要解决上述多线程并发访问一个资源的安全性问题:也就是解决重复票与不存在票问题，Java中提供了同步机制 (synchronized)来解决。那么怎么去使用呢？有三种方式完成同步操作：

• 同步代码块。
• 同步方法。
• 锁机制。

同步代码块

同步代码块： synchronized 关键字可以用于方法中的某个区块中，表示只对这个区块的资源实行互斥访问。

格式:

代码举例

package com.itheima.demo07.Synchronized;
/*卖票案例出现了线程安全问题卖出了不存在的票和重复的票解决线程安全问题的一种方案:使用同步代码块格式:synchronized(锁对象){可能会出现线程安全问题的代码(访问了共享数据的代码)}注意:1.通过代码块中的锁对象,可以使用任意的对象2.但是必须保证多个线程使用的锁对象是同一个3.锁对象作用:把同步代码块锁住,只让一个线程在同步代码块中执行*/
public class RunnableImpl implements Runnable{//定义一个多个线程共享的票源private  int ticket = 100;//创建一个锁对象Object obj = new Object();//设置线程任务:卖票@Overridepublic void run() {//使用死循环,让卖票操作重复执行while(true){//同步代码块synchronized (obj){//先判断票是否存在if(ticket>0){//提高安全问题出现的概率,让程序睡眠try {Thread.sleep(10);} catch (InterruptedException e) {e.printStackTrace();}//票存在,卖票 ticket--System.out.println(Thread.currentThread().getName()+"-->正在卖第"+ticket+"张票");ticket--;}}}}
}

同步方法

格式

同步锁是谁?

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

代码举例

package com.itheima.demo08.Synchronized;
/*卖票案例出现了线程安全问题卖出了不存在的票和重复的票解决线程安全问题的二种方案:使用同步方法使用步骤:1.把访问了共享数据的代码抽取出来,放到一个方法中2.在方法上添加synchronized修饰符格式:定义方法的格式修饰符 synchronized 返回值类型 方法名(参数列表){可能会出现线程安全问题的代码(访问了共享数据的代码)}*/
public class RunnableImpl implements Runnable{//定义一个多个线程共享的票源private static int ticket = 100;//设置线程任务:卖票@Overridepublic void run() {System.out.println("this:"+this);//this:com.itheima.demo08.Synchronized.RunnableImpl@58ceff1//使用死循环,让卖票操作重复执行while(true){payTicketStatic();}}/*静态的同步方法锁对象是谁?不能是thisthis是创建对象之后产生的,静态方法优先于对象静态方法的锁对象是本类的class属性-->class文件对象(反射)*/public static /*synchronized*/ void payTicketStatic(){synchronized (RunnableImpl.class){//先判断票是否存在if(ticket>0){//提高安全问题出现的概率,让程序睡眠try {Thread.sleep(10);} catch (InterruptedException e) {e.printStackTrace();}//票存在,卖票 ticket--System.out.println(Thread.currentThread().getName()+"-->正在卖第"+ticket+"张票");ticket--;}}}/*定义一个同步方法同步方法也会把方法内部的代码锁住只让一个线程执行同步方法的锁对象是谁?就是实现类对象 new RunnableImpl()也是就是this*/public /*synchronized*/ void payTicket(){synchronized (this){//先判断票是否存在if(ticket>0){//提高安全问题出现的概率,让程序睡眠try {Thread.sleep(10);} catch (InterruptedException e) {e.printStackTrace();}//票存在,卖票 ticket--System.out.println(Thread.currentThread().getName()+"-->正在卖第"+ticket+"张票");ticket--;}}}
}

Lock锁

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

• public void lock() :加同步锁。
• public void unlock() :释放同步锁。

使用如下：

package com.itheima.demo09.Lock;import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;/*卖票案例出现了线程安全问题卖出了不存在的票和重复的票解决线程安全问题的三种方案:使用Lock锁java.util.concurrent.locks.Lock接口Lock 实现提供了比使用 synchronized 方法和语句可获得的更广泛的锁定操作。Lock接口中的方法:void lock()获取锁。void unlock()  释放锁。java.util.concurrent.locks.ReentrantLock implements Lock接口使用步骤:1.在成员位置创建一个ReentrantLock对象2.在可能会出现安全问题的代码前调用Lock接口中的方法lock获取锁3.在可能会出现安全问题的代码后调用Lock接口中的方法unlock释放锁*/
public class RunnableImpl implements Runnable{//定义一个多个线程共享的票源private  int ticket = 100;//1.在成员位置创建一个ReentrantLock对象Lock l = new ReentrantLock();//设置线程任务:卖票@Overridepublic void run() {//使用死循环,让卖票操作重复执行while(true){//2.在可能会出现安全问题的代码前调用Lock接口中的方法lock获取锁l.lock();//先判断票是否存在if(ticket>0){//提高安全问题出现的概率,让程序睡眠try {Thread.sleep(10);//票存在,卖票 ticket--System.out.println(Thread.currentThread().getName()+"-->正在卖第"+ticket+"张票");ticket--;} catch (InterruptedException e) {e.printStackTrace();}finally {//3.在可能会出现安全问题的代码后调用Lock接口中的方法unlock释放锁l.unlock();//无论程序是否异常,都会把锁释放}}}}}

线程状态概述

当线程被创建并启动以后，它既不是一启动就进入了执行状态，也不是一直处于执行状态。在线程的生命周期中， 有几种状态呢？在API中 java.lang.Thread.State 这个枚举中给出了六种线程状态： 这里先列出各个线程状态发生的条件，下面将会对每种状态进行详细解析

                        

Timed Waiting（计时等待）

• 进入 TIMED_WAITING 状态的一种常见情形是调用的 sleep 方法，单独的线程也可以调用，不一定非要有协作关系。
• 为了让其他线程有机会执行，可以将Thread.sleep()的调用放线程run()之内。这样才能保证该线程执行过程 中会睡眠
• sleep与锁无关，线程睡眠到期自动苏醒，并返回到Runnable（可运行）状态。
• sleep()中指定的时间是线程不会运行的最短时间。因此，sleep()方法不能保证该线程睡眠到期后就 开始立刻执行。

Timed Waiting 线程状态图：

                                 

BLOCKED（锁阻塞） 

Blocked状态在API中的介绍为：一个正在阻塞等待一个监视器锁（锁对象）的线程处于这一状态。

Blocked 线程状态图

                                     

 

Waiting（无限等待）

Wating状态在API中介绍为：一个正在无限期等待另一个线程执行一个特别的（唤醒）动作的线程处于这一状态。

Waiting 线程状态图

                            

到此为止我们已经对线程状态有了基本的认识，想要有更多的了解，详情可以见下图

                         

线程间通信

• 概念：多个线程在处理同一个资源，但是处理的动作（线程的任务）却不相同。

为什么要处理线程间通信：

• 多个线程并发执行时,在默认情况下CPU是随机切换线程的，当我们需要多个线程来共同完成一件任务，并且我们希望他们有规律的执行,那么多线程之间需要一些协调通信，以此来帮我们达到多线程共同操作一份数据。

如何保证线程间通信有效利用资源：

• 多个线程在处理同一个资源，并且任务不同时，需要线程通信来帮助解决线程之间对同一个变量的使用或操作。就是多个线程在操作同一份数据时，避免对同一共享变量的争夺。也就是我们需要通过一定的手段使各个线程能有效的利用资源。而这种手段即——等待唤醒机制。

等待唤醒机制

什么是等待唤醒机制

• 这是多个线程间的一种协作机制。谈到线程我们经常想到的是线程间的竞争（race），比如去争夺锁，但这并不是 故事的全部，线程间也会有协作机制。就好比在公司里你和你的同事们，你们可能存在在晋升时的竞争，但更多时 候你们更多是一起合作以完成某些任务。
• 就是在一个线程进行了规定操作后，就进入等待状态（wait()）， 等待其他线程执行完他们的指定代码过后 再将 其唤醒（notify()）;在有多个线程进行等待时， 如果需要，可以使用 notifyAll()来唤醒所有的等待线程。
• wait/notify 就是线程间的一种协作机制。

等待唤醒中的方法

等待唤醒机制就是用于解决线程间通信的问题的，使用到的3个方法的含义如下：

• wait：线程不再活动，不再参与调度，进入 wait set 中，因此不会浪费 CPU 资源，也不会去竞争锁了，这时 的线程状态即是 WAITING。它还要等着别的线程执行一个特别的动作，也即是“通知（notify）”在这个对象 上等待的线程从wait set 中释放出来，重新进入到调度队列（ready queue）中
• notify：则选取所通知对象的 wait set 中的一个线程释放；例如，餐馆有空位置后，等候就餐最久的顾客最先入座。
• notifyAll：则释放所通知对象的 wait set 上的全部线程。

注意：

• 哪怕只通知了一个等待的线程，被通知线程也不能立即恢复执行，因为它当初中断的地方是在同步块内，而 此刻它已经不持有锁，所以她需要再次尝试去获取锁（很可能面临其它线程的竞争），成功后才能在当初调 用 wait 方法之后的地方恢复执行。

总结如下：

• 如果能获取锁，线程就从 WAITING 状态变成 RUNNABLE 状态； 否则，从 wait set 出来，又进入 entry set，线程就从 WAITING 状态又变成 BLOCKED 状态

调用wait和notify方法需要注意的细节

• wait方法与notify方法必须要由同一个锁对象调用。因为：对应的锁对象可以通过notify唤醒使用同一个锁对 象调用的wait方法后的线程。
• wait方法与notify方法是属于Object类的方法的。因为：锁对象可以是任意对象，而任意对象的所属类都是继 承了Object类的。
• wait方法与notify方法必须要在同步代码块或者是同步函数中使用。因为：必须要通过锁对象调用这2个方 法。

生产者与消费者问题

• 等待唤醒机制其实就是经典的“生产者与消费者”的问题。

代码演示：

包子资源类：

package ThreadDemo;public class BaoZi {String pier;String xianer;boolean flag = false;//包子资源 是否存在 包子资源状态
}

吃货线程类：

package ThreadDemo;public class ChiHuo  extends  Thread{private BaoZi bz;public ChiHuo(String name, BaoZi bz) {super(name);this.bz = bz;}@Overridepublic void run() {while (true) {synchronized (bz) {if (bz.flag == false) {//没包子try {bz.wait();} catch (InterruptedException e) {e.printStackTrace();}}System.out.println("吃货正在吃" + bz.pier + bz.xianer + "包子");bz.flag = false;bz.notify();}}}
}

包子铺线程类： ​​​​​​​

package ThreadDemo;public class BaoZiPu extends Thread {private BaoZi bz;public BaoZiPu(String name, BaoZi bz) {super(name);this.bz = bz;}@Overridepublic void run() {int count = 0;//造包子while (true) {//同步synchronized (bz) {if (bz.flag == true) {//包子资源 存在try {bz.wait();} catch (InterruptedException e) {e.printStackTrace();}}// 没有包子 造包子System.out.println("包子铺开始做包子");if (count % 2 == 0) {// 冰皮 五仁bz.pier = "冰皮";bz.xianer = "五仁";} else {// 薄皮 牛肉大葱bz.pier = "薄皮";bz.xianer = "牛肉大葱";}count++;bz.flag = true;System.out.println("包子造好了：" + bz.pier + bz.xianer);System.out.println("吃货来吃吧");//唤醒等待线程 （吃货）bz.notify();}}}
}

定义测试类

package ThreadDemo;public class Demo {public static void main(String[] args) {//等待唤醒案例BaoZi bz = new BaoZi();ChiHuo ch = new ChiHuo("吃货", bz);BaoZiPu bzp = new BaoZiPu("包子铺", bz);ch.start();bzp.start();}
}