多线程Thread

多进程概述

进程

• 1.定义：正在进行的程序（任务管理器中可以看到）（一个CPU同一时间点只运行一个进程，只运行其中的一个线程）。是系统进行资源分配和调用的独立单位。每一个进程都有他自己的内存空间和系统资源。
• 2.多进程有什么意义呢?
  
  • 可以提高CPU的使用率。

    　　单进程的计算机只能做一件事情，而我们现在的计算机都可以做多件事情。举例：一边玩游戏(游戏进程)，一边听音乐(音乐进程)。
    　　也就是说现在的计算机都是支持多进程的，可以在一个时间段内执行多个任务。

• 3.问题：一边玩游戏，一边听音乐是同时进行的吗?
  
  • 单cpu：
    不是。因为单CPU在某一个时间点上只能做一件事情。
    而我们在玩游戏，或者听音乐的时候，是CPU在做着程序间的高效切换让我们觉得是同时进行的。
  • 多CPU：可能是。

多线程

线程是依赖于进程而存在。

• 线程：在同一个进程内又可以执行多个任务，而这每一个任务我就可以看出是一个线程。
  （1）线程定义：是程序的执行单元，执行路径。是程序使用CPU的最基本单位。
  （2） 单线程：如果程序只有一条执行路径。
  （3）多线程：如果程序有多条执行路径。
  

  （360是一个进程，同时运行360的不同功能是多线程）；

  一个进程中至少有一个线程。
  （4）目的：开启多个线程是为了同时运行多部分代码。

• 程序：每一个线程都有自己运行的内容，这个内容可以成为线程要执行的程序。
• 多线程意义:为了提高应用程序的使用率。
  

  程序的执行其实都是在抢CPU的资源，CPU的执行权。

  多个进程是在抢这个资源，而其中的某一个进程如果执行路径比较多（线程多），就会有更高的几率抢到CPU的执行权。

  我们是不敢保证哪一个线程能够在哪个时刻抢到，所以线程的执行有随机性。

• 注意并行和并发:
  并行:是逻辑上同时发生，指在某一个时间段内同时运行多个程序。
  并发:是物理上同时发生，指在某一个时间点同时运行多个程序。
• Java程序运行原理
  由java命令启动JVM，JVM启动就相当于启动了一个进程。接着由该进程创建了一个主线程去调用main方法。
• jvm虚拟机的启动是单线程的还是多线程的?
  多线程的。
  原因是垃圾回收线程（finalize()）也要先启动，否则很容易会出现内存溢出。
  垃圾回收线程+主线程，最低启动了两个线程，所以，jvm的启动其实是多线程的。
• 多线程的好处：解决了多部分同时运行的问题
  

  如果多线程中的某一条线程发生错误,会显示异常,并停止这条线程,但其他线程不受影响.

• 创建线程的目的：
  是为了开启一条执行路径，去运行指定的代码和其他代码实现同时运行。
• 多线程实现：
  由C/C++去调用系统功能创建进程，然后由Java去调用进程实现多线程

1.多线程优点：

• 资源利用率更好
• 程序设计在某些情况下更简单
• 程序响应更快

2.多线程缺点：

• 设计更复杂
• 上下文切换的开销：上下文切换并不廉价。如果没有必要，应该减少上下文切换的发生。
• 增加资源消耗。

3.多线程有几种实现方案，分别是哪几种?
两种。
1.继承Thread类
2.实现Runnable接口

扩展一种：实现Callable接口。这个得和线程池结合。(一般可以不答)

线程调度

线程调度概述

假如我们的计算机只有一个CPU，那么CPU 在某一个时刻只能执行一条指令，线程只有得到CPU时间片，也就是使用权，才可以执行指令。

线程有两种调度模型：

• 分时调度模型:所有线程轮流使用CPU 的使用权，平均分配每个线程占用CPU 的时间片
• 抢占式调度模型:优先让优先级高的线程使用CPU，如果线程的优先级相同，那么会随机选择一个，优先级高的线程获取的CPU 时间片相对多一些。

Java使用的是抢占式调度模型。

线程优先级

• 线程默认优先级是：5
• 线程优先级的范围是：1-10
• 线程优先级：最大为10，最小为1，默认为5

设置对象优先级

public class ThreadPriorityDemo {
    public static void main(String[] args) {
           ThreadPriority tp1 = new ThreadPriority();
           ThreadPriority tp2 = new ThreadPriority();
          //设置线程名
           tp1.setName("东方不败");
           tp2.setName("岳不群");
           // 获取默认优先级
           System.out.println(tp1.getPriority());        
           //设置线程优先级
           tp1.setPriority(10);
           tp2.setPriority(1);
           System.out.println(tp1.getPriority());
           System.out.println(tp2.getPriority());
           tp1.start();
           tp2.start();
    }
}
///////////////
5-----默认是5
10---设置后
1
5
东方不败:0
东方不败:1

注意：
线程优先级高仅仅表示线程获取的 CPU时间片的几率高，但是要在次数比较多，或者多次运行的时候才能看到比较好的效果。

线程控制：其他方法

线程睡眠sleep

public class SleepThread extends Thread{
    public void run(){
        for(int i = 0 ; i < 5 ;i++){
            try{
                Thread.sleep(2000);//此线程sleep时，会运行其他线程
//只能用try catch，不能throws，因为父类没抛这个异常，子类也不能抛
//Thread.sleep(1000);//可以直接写sleep(1000);而省略Thread
            }catch(Exception ex){}
            System.out.println(getName()+"  "+i);
        }
    }
}
SleepThread s1 = new SleepThread();
SleepThread s2 = new SleepThread();
s1.setName("意");
s2.setName("而");
s1.start();
s2.start();

线程加入 join()：

等待该线程终止，只有这个线程完毕，其他线程才可以继续

public class SleepThread extends Thread{
    public void run(){
        for(int i = 0 ; i < 50 ;i++){
            System.out.println(getName()+"  "+i);
        }
    }
}
//__________________
SleepThread s1 = new SleepThread();
SleepThread s2 = new SleepThread();
SleepThread s3 = new SleepThread();
s1.setName("111");s2.setName("222");s3.setName("333");
s1.start();
s1.join();//将1线程加入
s2.start();   
s3.start();

线程礼让，暂停当前线程，执行其他线程

注意：
理论上是一个线程执行一次后，等待下一个线程执行，然后第一个线程再执行第二次，……实际上可能有"误差"

public void run() {
       for (int x = 0; x < 100; x++) {
              System.out.println(getName() + ":" + x);
            Thread.yield();
       }
}
//____________________________________________________
ThreadYield ty1 = new ThreadYield();
ThreadYield ty2 = new ThreadYield();
ty1.setName("林青霞");
ty2.setName("刘意");
ty1.start();
ty2.start();

后台线程

关羽张飞守护刘备,刘备完成走了,关羽张飞就也走了

ThreadDaemon td1 = new ThreadDaemon();
ThreadDaemon td2 = new ThreadDaemon();
td1.setName("关羽");
td2.setName("张飞");
// 设置守护线程(注意：必须在start()方法之前设置，否则会有异常！！)
td1.setDaemon(true);
td2.setDaemon(true);
td1.start();
td2.start();
Thread.currentThread().setName("刘备");//改一改main线程的名字
for (intx = 0; x < 5; x++) {
         System.out.println(Thread.currentThread().getName() + ":" + x);
}
但是不会立马结束，还会运行几次

中断线程

public class ThreadStopDemo {
    public static void main(String[] args) {
           ThreadStop ts = new ThreadStop();
           ts.start();
           try {
                  Thread.sleep(3000);
                  ts.stop();//3s后会停止程序
           } catch (InterruptedException e) {
                  e.printStackTrace();
}}}

--3s后程序停止

public static void main(String[] args) {
    ThreadStop ts = new ThreadStop();
    ts.start();
    try {
           Thread.sleep(3000);
            ts.interrupt();//结束线程，运行catch内容
    } catch (InterruptedException e) {
           e.printStackTrace();
    }
}

好处：不影响后续代码执行(继续运行catch之后的)

线程的生命周期

• 新建new：创建线程对象
• 就绪：有执行资格，没有执行权
• 运行runable：有执行资格，有执行权
• 阻塞：由于一些操作（sleep()，wait()）让线程处于了该状态。没有执行资格，没有执行权;而另一种操作（sleep()时间到，notify()）却可以把它激活，激活后处于就绪状态
• 死亡：线程对象变成垃圾，等待回收。

CPU同一时刻只能处理一个线程,多线程是多个线程轮流运行,允许运行但在等待的线程处于阻塞状态。

• CPU的执行资格:可以被CPU处理,在处理队列中排队;
• CPU的执行权:正在被CPU处理;

实现多线程

1.继承Thread类

• 实现步骤

1.继承Thread类
2.重写run方法
3.直接创建Thread的子类对象创建线程。
4.调用start方法开启线程并调用线程的任务run方法执行。

• Run方法中定义的是线程中要运行的任务代码
  

  不是类中的所有代码都需要被线程执行的，为了区分哪些代码能够被线程执行，java提供了Thread类中的run()用来包含那些被线程执行的代码。（代码若想被多线程执行，必须写（封装）在run里面）

  一般来说，被线程执行的代码肯定是比较耗时的。

• 方法：

• run()和start()区别
  run():仅仅是封装被线程执行的代码，直接调用是普通方法，是按顺序运行
  start():首先启动了线程，然后再由jvm去调用该线程的run()方法，是随机运行

注意：
同一个线程只能调用一次！！（如my.start();只能用一次，第二次会显示异常IllegalThreadStateException）

• 简单示例：

//创建一个类,继承Thread,实现run方法
public class MyThread extends Thread {
    public void run() {
        for (int x = 0; x < 10000; x++) {
            System.out.println(x);
        }
    }
}
//测试,调用线程直接new一个,start即可
public class MyThreadDemo {
    public static void main(String[] args) {
        // 创建两个线程对象
        MyThread my1 = new MyThread();//开启一个新的线程
        MyThread my2 = new MyThread();
        my1.start();//执行线程
        my2.start();
    }
}
//-----
这是三个线程，my1,my2，main

线程名称

• 无参构造

public class MyThread extends Thread {
    public void run() {
        for (int x = 0; x < 100; x++) {
            System.out.println(getName() + ":" + x);
 }   
}}

• 带参构造

public class MyThread extends Thread {
    public MyThread() {}
    ////在这里可以设置线程名比如super("林");
    public MyThread(String name){
        super(name);
    }
    @Override
    public void run() {
        for (int x = 0; x < 100; x++) {
            System.out.println(getName() + ":" + x);
        }
    }
}

获取线程名称

//在main方法中调用
MyThread my1 = new MyThread();
MyThread my2 = new MyThread();
System.out.println("main线程："+Thread.currentThread().getName());//获取主线程名称
my1.start();
my2.start();
//*************************************************************************
main线程：main
Thread-1:0
Thread-1:1

设置线程名称:2种

无参构造设置线程名

MyThread my1 = new MyThread();
MyThread my2 = new MyThread();
my1.setName("林青霞");
my2.setName("刘意");
my1.start();
my2.start();
////////
林青霞:0
刘意:0...

带参构造

MyThread my1 = new MyThread("林青霞");
MyThread my2 = new MyThread("刘意");
my1.start();
my2.start();
//****************
林青霞:13
刘意:0

2.实现Runnable接口(常用)

概述

1.为什么要给Thread类的构造函数传递Runnable的子类对象？

因为线程的任务都封装在Runnable接口子类对象的run方法中。所以要在线程对象创建时就必须明确要运行的任务。

2.为什么可以避免由于Java单继承带来的局限性

比如说，某个类已经有父类了，而这个类想实现多线程，但是这个时候它已经不能直接继承Thread类了(接口可以多实现implements，但是继承extends只能单继承)，它的父类也不想继承Thread因为不需要实现多线程。

3.实现Runnable接口的好处：

• 可以避免由王Java单继承带来的 限性。
• 适合多个相同程序的代码去处理同一个资源的情况,把线程同程序的代码,数据有效分离,较好的体现了面问对象的设计思想。

实现

• 实现步骤

1,实现Runnable接口。
2,重写run方法，将线程的任务代码封装到run方法中。
3,创建本类的对象
4,创建Thread类的对象，并把3步骤的对象作为构造参数传递。

• 编写实现类

class Demo implements Runnable{      //通过接口的形式完成。
public void run(){                    //覆盖接口中的run方法
    for(int x=0; x<100; x++)
       System.out.println(Thread.currentThread().getName()+"....."+x);//获取名称，只能间接用
    }
}

• 不初始化线程名:

class  ThreadDemo{
    public static void main(String[] args) {   
        Demo d = new Demo();
//注意：MyRunnable对象只需要创建一个即可，多个Thread对象可以接收同一个MyRunnable对象
        Thread t1 = new Thread(d);//通过Thread类创建线程对象，并传递Runnable。
        Thread t2 = new Thread(d);
        t1.start();
        t2.start();
    }
}
//-----结果---------
Thread-0...0
Thread-0...1

• 初始化线程名

Demo my = new Demo();
Thread t1 = new Thread(my, "林青霞");    //创建，初始化线程名
Thread t2 = new Thread(my, "刘意");
t1.start();
t2.start();
//****************************
林青霞...84
刘意...64

线程安全问题

• 导致安全问题的出现的原因：
  • 多个线程在操作共享的数据。
  • 操作共享数据的线程代码有多条。

当一个线程在执行操作共享数据的多条代码过程中，其他线程参与了运算。就会导致线程安全问题的产生。(例如,卖票,多线程,可能把数据卖到-1,因为各线程互相独立)

注：线程安全问题在理想状态下，不容易出现，但一旦出现对软件的影响是非常大的。

• 解决思路--同步代码块
  

  就是将多条操作共享数据的线程代码封装起来，当有线程在执行这些代码的时候，其他线程时不可以参与运算的。必须要当前线程把这些代码都执行完毕后，其他线程才可以参与运算。(同一时间,只能有一个线程参与运算---同步机制)

• 回顾以前线程安全的类

StringBuffer sb = new StringBuffer();
Vector<String> v = new Vector<String>();
Hashtable<String, String> h = new Hashtable<String, String>();
（在定义时就锁了，因此效率低）

注意:Vector是线程安全的时候才去考虑使用的，但是即使要安全，也不用

• 把一个线程不安全的集合类变成一个线程安全的集合类：

以前的：List list1 = new ArrayList();// 线程不安全

public static <T> List<T> synchronizedList(List<T> list)
List<String> list2 = Collections.synchronizedList(new ArrayList<String>()); // 线程安全

实现卖电影票案例(不安全)

某电影院目前正在上映贺岁大片，共有100张票，而它有3个售票窗口售票，请设计一个程序模拟该电影院售票。

方式1：继承Thread类

public class SellTicket extends Thread {
    // 定义100张票
  // 为了让多个线程对象共享这100张票，我们其实应该用静态修饰
    private static int tickets = 100;
    public void run() {
        // 定义100张票
        // 每个线程进来都会走这里，这样的话，每个线程对象相当于买的是自己的那100张票，这不合理，所以应该定义到外面
        // 是为了模拟一直有票
        while (true) {
            if (tickets > 0) {
                System.out.println(getName() + "正在出售第" + (tickets--) + "张票");
            }
}}}

调用

public class SellTicketDemo {
    public static void main(String[] args) {
        // 创建三个线程对象
        SellTicket st1 = new SellTicket();
        SellTicket st2 = new SellTicket();
        SellTicket st3 = new SellTicket();
        // 给线程对象起名字
        st1.setName("窗口1");  st2.setName("窗口2");  st3.setName("窗口3");
        // 启动线程
        st1.start();  st2.start();  st3.start();
    }
}

----

说明的是，通过继承Thread类来实现题中的需求并不是很好(tickets要用static修饰，并不太好)，其实用Runnable接口更好地进行数据分离

方式2：实现Runnable接口

public class SellTicket implements Runnable {
    // 定义100张票
    private int tickets = 100;
    public void run() {
        while (true) {
            if (tickets > 0) {
                System.out.println(Thread.currentThread().getName() + "正在出售第" + (tickets--) + "张票");
            }
        }
    }
}

调用

public class SellTicketDemo {
    public static void main(String[] args) {
        // 创建资源对象
        SellTicket st = new SellTicket();
        // 创建三个线程对象
        Thread t1 = new Thread(st, "窗口1");
        Thread t2 = new Thread(st, "窗口2");
        Thread t3 = new Thread(st, "窗口3");
        // 启动线程
        t1.start();t2.start(); t3.start();
    }
}

问题分析：同票和负数票

这种代码会有安全隐患，比如一个窗口获取票后，过来一段时间才订，在这段时间其他窗口就运行了，此处以sleep模拟，让每个线程休息一段时间

 if (tickets > 0) {
    // 为了模拟更真实的场景，我们稍作休息
     try {
        Thread.sleep(100); // t1就稍作休息,t2就稍作休息
     } catch (InterruptedException e) {
      e.printStackTrace();
   }
    System.out.println(......);
}}}}

但是出问题了!!!

• 问题1：出现了重复的票：
  

  CPU的一次操作必须是原子性的(在读取tickets--的原来的数值和减1之后的中间挤进了两个线程而出现重复)

• 问题2：出现了0和负票：
  

  　随机性和延迟导致的(三个线程同时挤进一个循环里，tickets--的减法操作有可能在同一个循环中被执行了多次而出现越界的情况，比如说tickets要大于0却越界到了-1)

也就是说，线程1执行的同时线程2也可能在执行，而不是线程1执行的时候线程2不能执行。

这就是线程的安全问题

• 解决方法：(下方有实现)
  • 同步代码块
  • 同步方法（简洁）
  • lock锁：

同步（synchronized）

同步概述

同一时间,只能有一个线程访问该代码;

同步可以解决安全问题的根本原因就在那个对象synchronized上。该对象如同锁的功能。(对象锁,同步锁)

格式：

synchronized(对象){
       需要被同步的代码 ；
}

• 同步的特点
  • 同步的前提：同步中必须有多个线程并使用同一个锁。未满足这两个条件，不能称其为同步。
  • 同步的好处: 解决了线程的安全问题.
  • 同步的弊端：当线程相当多时，因为每个线程都会去判断同步锁，这是很耗费资源的，无形中会降低程序的运行效率。

同步方法

• 方法1：同步代码块

Object obj = new Object();//同步,必须作为成员变量, 不能放在run内,
public void run(){   
    synchronized(obj){…}
}

• 方法2：

public void run(){   
    synchronized(this或Ticket.class){…}
}

• 方法3：同步方法

public synchronized void add(int num){...}

同步代码块

• 同步代码块的锁对象是：任意对象

买票同步代码块

票是按顺序减少的且没有了同票和负票

//卖票，共有100张票，多个线程同时卖票，一张票只能卖一次
public class SellTicket implements Runnable {
    // 定义100张票
    private int tickets = 100;
    //创建锁对象
    private Object obj = new Object();
    public void run() {
        while (true) {
            synchronized (obj) {//必须用在run外面定义的obj，而不能用new Object，那样不是同一把锁，还会出错
                if (tickets > 0) {
                    try {
                        Thread.sleep(100);
                        } catch (InterruptedException e) {
                            e.printStackTrace();}
                    System.out.println(Thread.currentThread().getName()
                            + "正在出售第" + (tickets--) + "张票");
                    }
                }
            }
        }
}

调用

public class SellTicketDemo {
    public static void main(String[] args) {
        // 创建资源对象
        SellTicket st = new SellTicket();
        // 创建三个线程对象
        Thread t1 = new Thread(st, "窗口1");
        Thread t2 = new Thread(st, "窗口2");
        Thread t3 = new Thread(st, "窗口3");
        // 启动线程
        t1.start();
        t2.start();
        t3.start();
    }
}

票是按顺序减少的且没有了同票和负票

同步方法

public synchronized void add(int num){ … }

• 同步方法用的锁：this
• 静态方法的锁对象是：当前类名.class，可以用对象.getClass()方法获取也可以用 类名.class表示;
• 同步方法的格式:把同步关键字加在方法上。
• 同步函数和同步代码块的区别：
  
  • 同步函数的锁是固定的this。
  • 同步代码块的锁是任意的对象。

  建议使用同步代码块。

public static synchronized void show(){}（其中num要该为static）

买票同步方法

方法1

//定义出售的票源
public class Tickets implements Runnable{
    private  int ticket = 100;
    public void run(){
        while(true){
           payTicket();
        }
    }
    public  synchronized void payTicket(){   
            if( ticket > 0){
                try{
                   Thread.sleep(10);
                }catch(Exception ex){}
                System.out.println(Thread.currentThread().getName()+" 出售第 "+ticket--);
            }
    }
}

方法2

会出错，因为第一个synchronized的锁是d，而第二个同步方法的锁是this，会出错

• 方法：
  • 方法1.把第一个的锁换成：this
  • 方法2.在第二个方法锁的第一行加上同样的锁synchronized(d)

public class Tickets implements Runnable{
    private  int ticket = 100;
    private int x = 0;
    //run方法定义
    public void run() {
        while (true) {
            if(x%2==0){
                synchronized (d) {//this
                    if (tickets > 0) {
                        try {
                            Thread.sleep(100);
                            } catch (InterruptedException e) {
                                e.printStackTrace();
                                }
                        System.out.println(Thread.currentThread().getName() + "正在出售第" + (tickets--) + "张票 ");
                        }
                    }
                }else {
                    sellTicket();
                    }
            x++;
            }
        }
    //-------------测试-----------
    private static synchronized void sellTicket() {
        if (tickets > 0) {
            try {
           //     Thread.sleep(100);//延时
                } catch (InterruptedException e) {
                    e.printStackTrace();
                    }
            System.out.println(Thread.currentThread().getName()  + "正在出售第" + (tickets--) + "张票 ");
        }
    } 
}

方法3:静态方法锁

在总票数和同步方法上添加static

出错，静态方法锁不能用this，需要用的是当前类的class对象：SellTicket.class

public class Tickets implements Runnable{
    private static int tickets = 100;// 用静态方法锁，ticket必须加静态
    private int x = 0;
    public void run() {
        while (true) {
            if (x % 2 == 0) {
                synchronized (this) {// SellTicket.class
                    if (tickets > 0) {
                        try {
                            Thread.sleep(10);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        System.out.println(Thread.currentThread().getName() + "正在出售第" + (tickets--) + "张票 ");
                    }
                }
            } else {
                sellTicket();
            }
            x++;
        }
    }
    private static synchronized void sellTicket() {
        if (tickets > 0) {
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "正在出售第" + (tickets--) + "张票 ");
        }
    }
}

银行存钱案例

两个人到银行存钱，每人存3次，每次100‘

class Bank {// 建立银行类
    private int sum;// 金库
    public synchronized void add(int num) {// 同步函数（第二种写法），存钱
        sum = sum + num;
        try {
            Thread.sleep(10);
        } catch (InterruptedException e) {} // 延时等待，使顺序
        System.out.println("sum=" + sum);// 显示金库余额
    }
}
class Cus implements Runnable {// 定义线程类
    private Bank b = new Bank();
    public void run() {// 覆盖run方法
        for (int x = 0; x < 3; x++) {// 存钱，存三次，每次100
            b.add(100);
        }
    }
}// 循环有次数限制，不会出现死循环
class BankDemo {
    public static void main(String[] args) {
        Cus c = new Cus();// 实例化线程类
        Thread t1 = new Thread(c);// Thread
        Thread t2 = new Thread(c);
        t1.start();// 开启线程
        t2.start();
    }
}

Lock锁（JDK5之后）

虽然我们可以理解同步代码块和同步方法的锁对象问题，但是我们并没有直接看到在哪里加上了锁，在哪里释放了锁，为了更清晰的表达如何加锁和释放锁，JDK5以后提供了一个新的锁对象Lock

ReentrantLock是Lock的实现类（序列化类）

Lock锁卖票案例

public class SellTicket implements Runnable {//实现接口
    private int tickets = 100;
    // 定义锁对象
    private Lock lock = new ReentrantLock();
    public void run() {
        while (true) {
            try {
                // 加锁
                lock.lock();
                if (tickets > 0) {
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + "正在出售第" + (tickets--) + "张票");
                }
            } finally {
                // 释放锁
                lock.unlock();// 放在finally中，使释放锁必须进行
            }
        }
    }
}

线程死锁

死锁问题及其代码

• 同步锁使用的弊端：当线程任务中出现了多个同步(多个锁)时，如果同步中嵌套了其他的同步。这时容易引发一种现象：程序出现无限等待，这种现象我们称为死锁。这种情况能避免就避免掉。
• 死锁前提：多线程，同步嵌套
• 线程进入同步取锁，进去了不出去
• 死锁概述:是指两个或者两个以上的线程在执行的过程中，因争夺资源产生的一种互相等待现象

死锁案例

方法1

1.定义锁对象类，两个锁A和B

public class MyLock {
    public static final Object lockA=new Object();
    public static final Object lockB=new Object();
}

2.线程任务类

public class ThreadTask implements Runnable {
    int x = new Random().nextInt(2);// 0,1 获取[0,2)之间随机值
    // 指定线程要执行的任务代码
    public void run() {
        while (true) {
            if (x % 2 == 0) {
                // 情况一
                synchronized (MyLock.lockA) {
                    System.out.println("if-LockA");
                    synchronized (MyLock.lockB) {
                        System.out.println("if-LockB");
                        System.out.println("if大口吃肉");
                }  }
            } else {
                // 情况二
                synchronized (MyLock.lockB) {
                    System.out.println("else-LockB");
                    synchronized (MyLock.lockA) {
                        System.out.println("else-LockA");
                        System.out.println("else大口吃肉");
            }   }     }
            x++;
} }}

3.测试类

public class ThreadDemo {
    public staticvoid main(String[] args) {
        // 创建线程任务类对象
        ThreadTask task = new ThreadTask();
        // 创建两个线程
        Thread t1 = new Thread(task);
        Thread t2 = new Thread(task);
        // 启动线程
        t1.start();
        t2.start();
    }
}

方法2：

定义两个锁：

public class LockA {
    // 做一个私有构造器，保证锁是私有的
    private LockA() {}
    // 为了让其他类可以调用，这样调用，用final使其他类不能修改
    // 只能通过类名调用静态成员获得
    public static final LockA locka = new LockA();
}
///////////////////
public class LockB {
    private LockB() {}
    public static final LockB lockb = new LockB();
}

线程任务类

public class DeadLock implements Runnable {// 写死循环
    private int i = 0;
    public void run() {
        while (true) {
            if (i % 2 == 0) {// 偶数
                // 先进入A同步,再进入B同步
                synchronized (LockA.locka) {
                    System.out.println("if...locka");// 先进入A同步
                    synchronized (LockB.lockb) {
                        System.out.println("if...lockb");
                    }
                }
            } else {
                // 先进入B同步,再进入A同步
                synchronized (LockB.lockb) {
                    System.out.println("else...lockb");// 先进入B同步
                    synchronized (LockA.locka) {
                        System.out.println("else...locka");
                    }
                }
            }
            i++;// 一次奇数一次偶数
        }
    }
}

测试类

public class DeadLockDemo {
    public static void main(String[] args) {
        DeadLock dead = new DeadLock();
        Thread t0 = new Thread(dead);
        Thread t1 = new Thread(dead);
        t0.start();
        t1.start();
        }
}
//------结果---
if...locka 
if...lockb 
else...lockb 
if...locka 形成死锁

线程间通信

线程间通信概述

线程间通讯：多个线程在处理同一资源，但是任务却不同。（不同线程处理同一个资源）
例程:

//资源,一对一，输入一个,输出一个
class Resource {
    String name;
    String sex;
}

生产者

// 输入，生产者（输入），对资源对象Resource中成员变量赋值
class Input implements Runnable {//实现接口
    Resource r;// 反参数传递，因为：输入输出是同一个资源，不能用new了，可以加private
    Input(Resource r) { this.r = r; }// 反参数传递，构造函数，可以加public
    public void run() {
        int x = 0;
        while (true) {
            synchronized (r) {// 解决线程问题，与输出锁相同, 同步必须在while里面
                if (x == 0) {// x两次切换赋值，使得好像输入很多
                    r.name = "mike";
                    r.sex = "nan";
                } else {
                    r.name = "丽丽";
                    r.sex = "女女";
            } }
            x = (x + 1) % 2;// x的0、1变化
}}}

消费者

//输出，消费者（输出）
class Output implements Runnable {
    Resource r;
    Output(Resource r) {  this.r = r;}
    public void run() {
        while (true) {
            synchronized (r) {// 和输入要用相同的锁,同步必须在while里面
                System.out.println(r.name + "....." + r.sex);
            }
        }
    }
}

测试

class aaa {
    public static void main(String[] args) {
        Resource r = new Resource();// 创建资源。
        Input in = new Input(r);// 创建任务
        Output out = new Output(r);
        Thread t1 = new Thread(in);// 创建线程，执行路径。
        Thread t2 = new Thread(out);
        t1.start();// 开启线程
        t2.start();
    }
}

• 优化:使输入和输出一对一：(下方的等待/唤醒机制案例)

等待/唤醒机制

虽然数据安全了，但是呢，一次一大片不好看(获取同一个数据一次而输出多次，也就是set一次却get了多次)，我就想依次的一次一个输出(也就是set一次get一次)。

如何实现呢?

通过Java提供的等待唤醒机制解决。

在Object类中提供了方法:

• 涉及方法：

这些方法都必须定义在同步中。因为这些方法是用于操作线程状态的方法。必须要明确到底操作的是哪个锁上的线程。

• 为什么wait、notify、notifyAll定义在了Object类中？

因为这些方法的调用是依赖于锁对象的，而同步代码块的锁对象是任意锁。任意的对象调用的方式一定定义在Object类中。

• wait 和 sleep 区别？

方法

生产消费:加入等待唤醒机制，加入判断**

方法1（更好）：

资源类

class Resource {
    private String name;// 安全优化，私有化
    private String sex;// 安全优化，私有化
    private boolean flag = false;// 一对一输入输出
    public synchronized void set(String name, String sex) {
        if (flag) // 若资源有内容，暂时不输入，等输出后再赋值
            try { this.wait();
            } catch (InterruptedException e) {
            }
        // wait需要异常处理
        this.name = name;
        this.sex = sex;
        flag = true;
        this.notify();// 赋值完成，唤醒输出
    }
    public synchronized void out() {
        if (!flag)// 若资源无内容，暂时不输出
            try { this.wait();
            } catch (InterruptedException e) {
            }
        System.out.println(name + "..." + sex);
        flag = false;// 输出完成，定义flag无内容
        this.notify();// 唤醒输入
    }
}

输入

class Input implements Runnable {
    Resource r;// 反参数传递，因为：输入输出是同一个资源，不能用new了
    Input(Resource r) {
        this.r = r;
    }// 反参数传递，构造函数
    public void run() {
        int x = 0;
        while (true) {
            if (x == 0)// x两次切换赋值，使得好像输入很多
                r.set("mike", "nan");
            else
                r.set("丽丽", "女女女女女女");
            x = (x + 1) % 2;// x的0、1变化
}    }}

输出

class Output implements Runnable {
    Resource r;
    Output(Resource r) {this.r = r;}
    public void run() {
        while (true) { r.out();
}    }}

方法2：

资源

public class Student {
    String name;
    int age;
    boolean flag; // 判断默认情况是没有数据，如果是true，说明有数据
}

生产者

public class SetThread implements Runnable {
  //  生产者
    private Student s;
    private int x = 0;
    public SetThread(Student s) {
        this.s = s;
    }
    public void run() {
        while (true) {
            synchronized (s) {
                if (s.flag) { // 判断有没有
                    try {// 若有
                        s.wait(); // 等待（必须是锁的wait），并释放锁，释放CPU执行权；
                    } catch (InterruptedException e) {
                        e.printStackTrace();}
                }
                if (x % 2 == 0) {// 若没有，或没有了之后释放锁
                    s.name = "林青霞";
                    s.age = 27;
                } else {
                    s.name = "刘意";
                    s.age = 30;
                }
                x++; // x=1
                s.flag = true;// 生产完，修改标记，使进入消费
                s.notify(); // 唤醒t2,抢CPU的执行权。
            } // t1有，或者t2有
        }
    }
}

消费

public class GetThread implements Runnable {// 消费
    private Student s;
    public GetThread(Student s) {
        this.s = s;
    }
    public void run() {
        while (true) {
            synchronized (s) {
                if (!s.flag) {// 若此时没有
                    try {
                        s.wait(); // 等待。并立即释放锁。将来醒过来的时候，是从这里醒过来
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                System.out.println(s.name + "---" + s.age);// 当有内容的时候，
                // 林青霞---27
                // 刘意---30
                s.flag = false; // 修改标记防止再次进入消费
                s.notify();// 唤醒线程唤醒t1
            }
        }
    }
}

测试

public class StudentDemo {
    public static void main(String[] args) {
        // 创建资源
        Student s = new Student();
        // 设置和获取的类
        SetThread st = new SetThread(s);
        GetThread gt = new GetThread(s);
        // 线程类
        Thread t1 = new Thread(st);
        Thread t2 = new Thread(gt);
        // 启动线程
        t1.start();
        t2.start();
    }
}
//-----结果----
林青霞---27
刘意---30
林青霞---27
刘意---30
林青霞---27   

优化生产消费问题

多生产者，多消费者的问题。烤鸭生产一只消费一只

资源

class Resource {
    private String name;// 商品名称
    private int count = 1;// 烤鸭编号
    private boolean flag = false;// 标记
    public synchronized void set(String name) {// 生产设置烤鸭名字
        while (flag)// while进行判断，如果正在烤
            try {this.wait();}
            catch (InterruptedException e) {} // 等待t1 t0
        this.name = name + count;// 烤鸭+编号----若已经消费了
        count++;// 下一个编号2 3 4
        System.out.println(Thread.currentThread().getName() + "..生产者.." + this.name);// 生产烤鸭1
        flag = true;
        notifyAll();// 多线程，只唤醒一个可能出现死锁，需要唤醒所有线程
    }
    public synchronized void out() {// 消费t3
        while (!flag)// 如果正在卖
            try {this.wait();}
        catch (InterruptedException e) {} // 等待t2 t3
        System.out.println(Thread.currentThread().getName() + "...消费者........" + this.name);// 消费烤鸭1
        flag = false;
        notifyAll();
    }
}

生产者

class Producer implements Runnable {// 生产者
    private Resource r;
    Producer(Resource r) {this.r = r;}// 构造
    public void run() {
        while (true) {r.set("烤鸭");} // 生产烤鸭
    }
}

消费者

class Consumer implements Runnable {// 消费者
    private Resource r;
    Consumer(Resource r) {this.r = r;}
    public void run() {
        while (true) {    r.out();} // 消费烤鸭
    }
}

测试

class ProducerCustomerDemo {
    public static void main(String[] args) {
        Resource r = new Resource();// 实例化资源
        Producer pro = new Producer(r);// 生产
        Consumer con = new Consumer(r);// 消费
        Thread t0 = new Thread(pro);// 线程t0负责生产
        Thread t1 = new Thread(pro);
        Thread t2 = new Thread(con);
        Thread t3 = new Thread(con);
        t0.start();
        t1.start();
        t2.start();
        t3.start();
    }
}
//----结果----
Thread-1..生产者..烤鸭136416
Thread-2...消费者........烤鸭136416
Thread-0..生产者..烤鸭136417
Thread-3...消费者........烤鸭136417
Thread-1..生产者..烤鸭136418
Thread-2...消费者........烤鸭136418
Thread-0..生产者..烤鸭136419
Thread-3...消费者........烤鸭136419
Thread-1..生产者..烤鸭136420
Thread-2...消费者........烤鸭136420
Thread-0..生产者..烤鸭136421

Condition等待/唤醒机制

jdk1.5以后将同步和锁封装成了对象。并将操作锁的隐式方式定义到了该对象中，将隐式动作变成了显示动作。

• Synchronized（）同步的锁是隐式的
• Lock接口： 出现替代了同步代码块Synchronized或者同步函数。将同步的隐式锁操作变成显示锁操作。同时更为灵活。可以一个锁上加上多组监视器。

Lock lock = new ReentrantLock();

• Condition接口：出现替代了Object中的wait、notify、notifyAll方法。将这些监视器方法单独进行了封装，变成Condition监视器对象。可以任意锁进行组合。

可以有多个监视器

优化生产消费问题

资源

//jdk1.5以后将同步和锁封装成了对象。
import java.util.concurrent.locks.*;
class Resource {
    private String name;
    private int count = 1;
    private boolean flag = false;
    Lock lock = new ReentrantLock();// 创建一个锁对象。
    // 通过已有的锁获取两组监视器，一组监视生产者，一组监视消费者。
    Condition producer_con = lock.newCondition();// 监视生产锁
    Condition customer_con = lock.newCondition();// 监视消费锁
    public void set(String name) {// 去掉synchronized同步
        lock.lock();// 获取锁---同步
        try {// 异常处理
            while (flag)// 用while，循环检测
                try {
                    producer_con.await();
                } catch (InterruptedException e) {
                } // 生产等待
            this.name = name + count;
            count++;
            System.out.println(Thread.currentThread().getName() + "...生产者5.0..." + this.name);// 生产烤鸭
            flag = true;
            customer_con.signal();// 生产完，释放另一组锁的一个，运行消费
        } finally {
            lock.unlock();
        } // 释放锁
    }
    public void out() {
        lock.lock();// 获取锁---同步
        try {
            while (!flag)// 用while，循环检测
                try {
                    customer_con.await();
                } catch (InterruptedException e) {
                } // 消费等待
            System.out.println(Thread.currentThread().getName() + "...消费者.5.0......." + this.name);// 消费烤鸭
            flag = false;
            producer_con.signal();// 消费后，释放另一组锁的一个，运行生产
        } finally {
            lock.unlock();
        } // 释放锁
    }
}