4.3 线程的停止
主方法也是一个线程，对于部署在主方法内其他的线程而言，如何让主方法这个线程让其他的线程提前结束呢？
线程的死亡有两种：
自然死亡：当一个线程的run方法执行完，线程自然会停止。
意外死亡：当一个线程遇到未捕获处理的异常，也会挂掉。
我们肯定希望是让线程自然死亡更好。
- public final void stop()：**强迫线程停止执行。 该方法具有固有的不安全性，已经标记为@Deprecated==（已过时、已废弃）==不建议再使用，**那么我们就需要通过其他方式来停止线程了，其中一种方式是使用变量的值的变化来控制线程是否结束。
- 标记法
案例：
声明一个PrintEvenThread线程类，继承Thread类，重写run方法，实现打印[1,100]之间的偶数，要求每隔1毫秒打印1个偶数。
声明一个PrintOddThread线程类，继承Thread类，重写run方法，实现打打印[1,100]之间的奇数在main线程中:
(1) 创建两个线程对象，并启动两个线程
(2)当打印奇数的线程结束了，让偶数的线程也停下来，就算偶数线程没有全部打印完[1,100]之间的偶数.
代码演示如下：
package test; //打印1-100之间的偶数 public class PrintEvenThread extends Thread { private boolean flag=true; public void setFlag(boolean flag) { this.flag = flag; } @Override public void run() { for (int i = 2; i <=100 & flag; i+=2) { try { Thread.sleep(1); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println("自定义异常打印【1-100】之间的偶数:"+i); } } } //打印1-100之间的奇数 public class PrintOddThread extends Thread { @Override public void run() { for (int i = 1; i <= 100 ; i+=2) { System.out.println("自定义异常打印【1-100】之间的奇数:"+i); } } } public class TestPrint { public static void main(String[] args) { PrintEvenThread p1=new PrintEvenThread();//偶数进程 PrintOddThread p2=new PrintOddThread();//奇数进程 p1.start(); p2.start(); try { p2.join(); } catch (InterruptedException e) { e.printStackTrace(); } p1.setFlag(false);//此时打印奇数的线程执行完了，就把打印偶数的进程停掉，即便之前它没有执行完 } }
五、线程安全问题
5.2 什么是线程安全问题？
当我们使用多个线程访问同一资源(可以是同一个变量、同一个文件、同一条记录等)的时候，若多个线程只有读操作，那么不会发生线程安全问题，但是如果多个线程中对资源有读和写的操作，就容易出现线程安全问题。
我们通过一个案例，演示线程的安全问题:
电影院要卖票，我们模拟电影院的卖票过程。假设要播放的电影是“葫芦娃大战奥特曼”，本次电影的座位共100个(本场电影只能卖100张票)。
我们来模拟电影院的售票窗口，实现多个窗口同时卖“葫芦娃大战奥特曼”这场电影票(多个窗口一起卖这100张票
代码如下（示例）：
public class TestTicket { public static void main(String[] args) { //创建3个窗口一起卖票 Ticket t1=new Ticket("窗口一"); Ticket t2=new Ticket("窗口二"); Ticket t3=new Ticket("窗口三"); t1.start(); t2.start(); t3.start(); } } class Ticket extends Thread{ //先假设需要卖10张票 private static int tickets=10; public Ticket(String name) { super(name); } @Override public void run() { while (tickets>=1){ try { Thread.sleep(2000);//线程休眠2000ms，即2s } catch (InterruptedException e) { e.printStackTrace(); } tickets--; System.out.println(Thread.currentThread().getName()+"卖了1张票,"+"还剩"+tickets+"票");//打印卖票信息以及余票情况 } } }
问题分析如下：
5.2 如何解决线程安全问题？
1、使用同步机制
同步就是给某段代码加“锁”
锁是一个对象，又被称为监视器对象·就是监视使用共享数据的这几个线程的调度执行情况
Java对象分为3个部分:
(1) 对象头 :
A:包含当前对象所属类的指针
B : Mark word : 记录了和当前对象有关的GC、锁标记等信息
c: 数组的长度，数组对象特有的
(2) 对象的实例变量
( 3) 对齐空白
即每一个对象都有一个标记位，标记现在哪个线程“占有”这个锁对象。这个标记为会记录这个线程的ID。只有“占有”锁对象的线程才有机会执行被锁的代码，称为同步代码
2、如何给代码加锁 ? synchronized
(1) 同步方法: 锁整个方法
[修饰符] synchronized 返回值类型 方法名( [形参列表] ) [throws 异常列表]
{
方法体
}
演示代码如下：
①情形：继承Thread类
public class TestTicket { public static void main(String[] args) { Ticket t1=new Ticket("窗口一"); Ticket t2=new Ticket("窗口二"); Ticket t3=new Ticket("窗口三"); t1.start(); t2.start(); t3.start(); } } class Ticket extends Thread{ private static int tickets =3; public Ticket(String name) { super(name); }; @Override public void run() { while (tickets >= 1){ sellOneTicket(); } } public static synchronized void sellOneTicket(){ if (tickets>=1) { try { Thread.sleep(20); } catch (InterruptedException e) { e.printStackTrace(); } tickets--; System.out.println(Thread.currentThread().getName() + "卖了1张票," + "还剩" + tickets + "票"); } } }*斜体样式*
②情形：实现Rannable接口
public class RunnableTickets implements Runnable{ private int tickets=10; @Override public void run() { while (tickets >= 1){ sellOneTicket(); } } //非静态方法的锁对象是this public synchronized void sellOneTicket(){ if (tickets >= 1) { try { Thread.sleep(20); } catch (InterruptedException e) { e.printStackTrace(); } tickets--; System.out.println(Thread.currentThread().getName() + "卖了1张票," + "还剩" + tickets + "票"); } } } public class TestRunnableTickets { public static void main(String[] args) { RunnableTickets rt=new RunnableTickets(); Thread t1=new Thread(rt,"窗口一"); Thread t2=new Thread(rt,"窗口二"); Thread t3=new Thread(rt,"窗口三"); t1.start(); t2.start(); t3.start(); } }
注意：
若以上代码中同步方法未加 if 条件判断，则还会出现-1的情况。
不信？请看如下代码：
原因分析如下：
(2) 同步代码块 : 锁方法体里面的一小部分代码
synchronized() {
需要被锁起来的代码
}
代码演示如下：
public class SafeMethod { public static void main(String[] args) { Tick t1=new Tick("窗口一"); Tick t2=new Tick("窗口二"); Tick t3=new Tick("窗口三"); t1.start(); t2.start(); t3.start(); } } class Tick extends Thread{ private static int tickets =100; private static Object lock=new Object(); public Tick(String name) { super(name); }; @Override public void run() { while (tickets >= 1) { synchronized (lock) { //不能使用this。因为在测试类中的t1,t2,t3所引用的类类型是同一个，若用this，达不到效果，锁对象不一致 if (tickets >= 1) { try { Thread.sleep(20); } catch (InterruptedException e) { e.printStackTrace(); } tickets--; System.out.println(Thread.currentThread().getName() + "卖了1张票," + "还剩" + tickets + "票"); } } } } }
(3) 什么时候释放锁 ?
当synchronized锁的代码全部执行完，才会释放锁
(4) 锁对象的选择问题 ?
①任意类型的对象都可以当做监视线程的锁对象。即类型不限制。
②必须保证使用共享数据的多个线程( 具有竞争关系的多个线程 )使用同一个锁对象·
③同步方法的锁对象是不能自由选择的，是默认的。
非静态方法的锁对象是this对象
备注：非静态方法的锁对象是实例对象本身（this）
静态方法的锁对象是当前类的class对象。
只要是同一个类，那么class就一定是同一个
六、守护线程
6.1 守护线程是什么？
有一种线程，它是在后台运行的，它的任务是为其他线程提供服务的，这种线程被称为“守护线程”。JVM的垃圾回收线程就是典型的守护线程。
当系统中所有的被守护线程都结束之后，守护线程就算自己的事情没有做完，也会自动结束即系统中不会只有守护线程在单独运行。
6.2 如何设置守护线程？
public final setDaemon(boolean on)：on为true，便可设置指定线程为守护线程
必须在线程启动之前设置，否则会报IllegalThreadStateException异常。
代码演示如下：
public class DemonThread { public static void main(String[] args) { MyDemon md=new MyDemon(); /* 这两句代码不能反着放，会触发线程非法状态异常：线程被启动了两次 md.setDaemon(true); md.start(); */ md.setDaemon(true); md.start(); for (int i = 1; i <201 ; i++) { System.out.println(i); } } } class MyDemon extends Thread{ @Override public void run() { while (true){ System.out.println("我一直在守护你.........."); try { Thread.sleep(100); } catch (InterruptedException e) { e.printStackTrace(); } } } }
七、等待唤醒机制
7.1 线程间通信
为什么要处理线程间通信：
多个线程在处理同一个资源，但是处理的动作（线程的任务）却不相同。而多个线程并发执行时, 在默认情况下CPU是随机切换线程的，当我们需要多个线程来共同完成一件任务，并且我们希望他们有规律的执行, 那么多线程之间需要一些通信机制，可以协调它们的工作，以此来帮我们达到多线程共同操作一份数据。
比如：线程A用来生成包子的，线程B用来吃包子的，包子可以理解为同一资源，线程A与线程B处理的动作，一个是生产，一个是消费，此时B线程必须等到A线程完成后才能执行，那么线程A与线程B之间就需要线程通信，即—— 等待唤醒机制。
7.2 等待唤醒机制
什么是等待唤醒机制
这是多个线程间的一种协作机制。谈到线程我们经常想到的是线程间的竞争（race），比如去争夺锁，但这并不是故事的全部，线程间也会有协作机制。
就是在一个线程满足某个条件时，就进入等待状态（wait()/wait(time)）， 等待其他线程执行完他们的指定代码过后再将其唤醒（notify()）;或可以指定wait的时间，等时间到了自动唤醒；在有多个线程进行等待时，如果需要，可以使用 notifyAll()来唤醒所有的等待线程。wait/notify 就是线程间的一种协作机制。
1.wait：线程不再活动，不再参与调度，进入 wait set 中，因此不会浪费 CPU 资源，也不会去竞争锁了，这时的线程状态即是 WAITING或TIMED_WAITING。它还要等着别的线程执行一个特别的动作，也即是“通知（notify）”或者等待时间到，在这个对象上等待的线程从wait set 中释放出来，重新进入到调度队列（ready queue）中
2. notify：则选取所通知对象的 wait set 中的一个线程释放；
3. notifyAll：则释放所通知对象的 wait set 上的全部线程。
注意：
被通知线程被唤醒后也不一定能立即恢复执行，因为它当初中断的地方是在同步块内，而此刻它已经不持有锁，所以她需要再次尝试去获取锁（很可能面临其它线程的竞争），成功后才能在当初调用wait 方法之后的地方恢复执行。
总结如下：
- 如果能获取锁，线程就从 WAITING 状态变成 RUNNABLE（可运行） 状态；
- 否则，线程就从 WAITING 状态又变成 BLOCKED（等待锁） 状态
调用wait和notify方法需要注意的细节
- wait方法与notify方法必须要由同一个锁对象调用。因为：对应的锁对象可以通过notify唤醒使用同一个锁对象调用的wait方法后的线程。
- wait方法与notify方法是属于Object类的方法的。因为：锁对象可以是任意对象，而任意对象的所属类都是继承了Object类的。
- wait方法与notify方法必须要在同步代码块或者是同步函数中使用。因为：必须要通过锁对象调用这2个方法。
如何判断有没有线程安全问题?
(1) 是否存在多个线程 (2个或2个以上的线程)
(2)这多个线程是否有共享数据，
如第五节线程安全问题中5.2中的不同代码块案例的tickets=100
(3) 多个线程是否既有读又有与操作(修改)
都包含的话，那么一定有线程安全。
有线程安全问题，就一定要加同步锁。
同步锁有两种加法，同步方法，同步代码块。
tips：
在java.Lang.Object类中: wait()；notify()；
当这两个方法不是线程的监视器对象调用时，会报ILLealMonitorStateException (非法监视器异常)
7.3 生产者与消费者问题
生产者消费者问题（英语：Producer-consumer problem），也称有限缓冲问题（英语：Bounded-buffer problem），是一个多线程同步问题的经典案例。该问题描述了两个共享固定大小缓冲区的线程——即所谓的“生产者”和“消费者”——在实际运行时会发生的问题。生产者的主要作用是生成一定量的数据放到缓冲区中，然后重复此过程。与此同时，消费者也在缓冲区消耗这些数据。该问题的关键就是要保证生产者不会在缓冲区已经装满时加入数据，消费者也不会在缓冲区为空时消耗数据。
生产者与消费者问题中其实隐含了两个问题：
- 线程安全问题：因为生产者与消费者共享数据缓冲区，不过这个问题可以使用同步解决。
- 线程的协调工作问题：
- 要解决该问题，就必须让生产者线程在缓冲区满时等待(wait)，暂停进入阻塞状态，等到下次消费者消耗了缓冲区中的数据的时候，通知(notify)正在等待的线程恢复到就绪状态，重新开始往缓冲区添加数据。同样，也可以让消费者线程在缓冲区空时进入等待(wait)，暂停进入阻塞状态，等到生产者往缓冲区添加数据之后，再通知(notify)正在等待的线程恢复到就绪状态。通过这样的通信机制来解决此类问题。
