一、线程概述

  1. 进程:是操作系统中一个程序及其数据在处理机上顺序执行时所发生的活动。一个进程包含多个线程。
  2. 线程:也成轻量进程，是进程中某个单一顺序的控制流
  3. 多进程:在操作系统中同时运行多个任务(程序)
  4. 多线程:在同-应用程序中有多个顺序流同时执行

  5. 线程的生命周期:一个线程从创建到执行完的整个过程

  6. 多线程的开发需要注意安全问题，需要使用到线程同步，加锁。

  7. JVM看做进程：
  • 垃圾回收线程（守护线程） ： 定时的去回收资源

  • 主线程 ：其实就是主函数 是由jvm直接调用的线程

    二、创建线程

    2.1 创建线程的方式一

    继承Thread类
    重写run方法

    1. public class MyThread01 extends Thread{
    2. public static void main(String[] args) {
    3.     //开启两个线程，采用抢占式获取cpu时间片。异步的状态。
    4. MyThread01 t1 = new MyThread01();
    5. t1.setName("线程一");
    6. MyThread01 t2 = new MyThread01();
    7. t2.setName("线程二");
    8. t1.start();
    9. t2.start();
    10. }
    12. @Override
    13. public void run() {
    14.     for(int i=1 ;i<100;i++){
    15.         System.out.println(Thread.currentThread().getName());
    16.         try {
    17.             Thread.sleep(500);
    18.         } catch (InterruptedException e) {
    19.             e.printStackTrace();
    20.         }
    21.     }
    22. }

2.2 创建线程的方式二

实现runnable实例

  1. public class MyThread02 {
  3.     public static void main(String[] args) {
  5.         //创建Runnable实例
  6.         MyRunnable myRunnable = new MyRunnable();
  8.         //创建线程对象
  9.         Thread t1 = new Thread(myRunnable);
  10.         Thread t2 = new Thread(myRunnable);
  12.         //开启线程
  13.         t1.start();//就绪状态，有争夺cou资源的能力；
  14.         t2.start();
  15.     }
  16. }

2.2 创建线程的方式三

通过匿名内部类创建线程 FutureTask

  1. public static void main(String[] args) {
  2.    Thread thread = new Thread(new runnable(){
  3.    public void run(){
  4.        for(int i=1 ;i<100;i++){
  5.           System.out.println(Thread.currentThread().getName());
  6.           try {
  7.              Thread.sleep(500);
  8.           } catch (InterruptedException e) {
  9.                 e.printStackTrace();
  10.             }
  11.         }
  12.    }
  13.    })   
  14.       t1.start();
  15.       t2.start();
  16. }

三、线程周期以及线程操作

  1. 新建态：创建出来时，线程处于的状态
  2. 就绪态：线程调用start方法后处于就绪状态
  3. 运行态：线程争夺到cup资源后，会进入run方法执行任务时所处状态；
  4. 阻塞态：当运行态的线程遇到睡眠、控制台打印后；

  5. 死亡态：执行完run方法后处于的状态。

  6. run方法执行方法；start方法启动方法

  7. start启动不一定执行run方法；
  8. 线程调度模型：抢占式（java默认方法）、时间片轮转；

可以通过设置抢占的优先级；

  1.         //获取线程的优先级的权重
  2.         int priority1 = t1.getPriority();
  3.         int priority2 = t2.getPriority();
  5.         System.out.println(t1+"============>"+priority1);
  6.         System.out.println(t2+"============>"+priority2);
  8.         //设置权重比例
  9.         t1.setPriority(9);
  10.         t2.setPriority(1);

  1. yield（）让位方法 运行态—>就绪态

    1. public void run() {
    3.     for (int i = 1 ; i < 100 ; i++){
    5.    /*     if (i % 5 == 0){
    7.    //让位方法，让当前线程从运行状态进入就绪状态，重新争夺cpu时间片
    8.             Thread.yield();
    9.         }
    10. */
    12.         //Thread.currentThread() 获取当前正在执行任务的线程
    13.         System.out.println(Thread.currentThread().getName()+" ===> "+i);

  2. 其他方法

  • join（）当前线程进入阻塞，指定线程执行，直到指定线程结束当前线程才可以继续。 ```java public static void main(String[] args) {

    MyThread06 t1 = new MyThread06(); t1.setName(“线程1”); t1.start();

    boolean alive = t1.isAlive();

    System.out.println(“t1线程是否是存活的状态 “+alive);

    for (int i = 1 ; i < 100 ; i++){

    1.   /*
    2.   main作为主线程，t1与main线程合并，
    3.   main需要等到ti执行结束才能继续执行；
    4.   if (i == 50){
    6.   try {
    8.   //合并线程
    9.   t1.join();
    11.   } catch (InterruptedException e) {
    13.   e.printStackTrace();
    14.   }        
    15.   }*/
    17.   System.out.println(Thread.currentThread().getName()+" ===> "+i);
    19.   //睡眠的方法
    20.   //自己把自己挂起
    21.   try {
    23.       Thread.sleep(100);
    25.   } catch (InterruptedException e) {
    27.       e.printStackTrace();
    28.   }

    } //唤醒t1线程 //t1.resume();

    try {

    1.   Thread.sleep(5000);

    } catch (InterruptedException e) {

    1.   e.printStackTrace();

    }

    //通过异常机制来中断睡眠 t1.interrupt();

}

/ 线程在执行任务的时候会调用该方法 / @Override public void run() {

  1. for (int i = 1 ; i < 100 ; i++){
  4.     if (Thread.currentThread().getName().equals("线程1")){
  6.         if (i == 50){
  8.             //线程自己把自己挂起 处于长久睡眠的状态
  9.             //Thread.currentThread().suspend();
  12.             //中断线程 让当前线程立即进入死亡状态
  13.             // Thread.currentThread().stop();
  15.             try {
  17.                 //睡眠一年
  18.                 Thread.sleep(1000 * 60 * 60 * 24 * 365);
  20.             } catch (InterruptedException e) {
  22.                 e.printStackTrace();
  23.             }
  25.         }
  27.     }
  29.     //Thread.currentThread() 获取当前正在执行任务的线程
  30.     System.out.println(Thread.currentThread().getName()+" ===> "+i);
  32.     //睡眠的方法
  33.     try {
  35.         Thread.sleep(100);
  37.     } catch (InterruptedException e) {
  39.         e.printStackTrace();
  40.     }
  42. }
  45. }
  2. - suspend0线程自己把自己挂起
  3. - resume(线程自己把自己唤醒
  4. > #t1.stop0:中断线程
  5. > interrupt()中断睡眠
  6. >  t1.isAlive()判断指定线程是否处于活动状态
  9. <a name="FUeiJ"></a>
  10. ### 四、“龟兔赛跑”案例
  11. >  需求描述：<br />赛道1000m，兔子100m/s ，乌龟50m/s，兔子到900米位置把（挂起）睡觉，乌龟一直跑，乌龟到终点唤起兔子。以线程模拟。
  13. ```java
  14. public class Rb extends Thread {
  16.     private String name;
  18.     public Rb(String name) {
  20.         super(name);
  22.         this.name = name;
  23.     }
  25.     @Override
  26.     public void run() {
  29.         for (int i = 0; i <= 900 ; i+=100) {
  31.             System.out.println(Thread.currentThread().getName()+"跑了"+(i + 100)+"米");
  33.             if (i == 800){
  35.                 System.out.println(Thread.currentThread().getName() +"开始睡觉了。。。。。。");
  37.                 //兔子自己把自己挂起
  38.                 Thread.currentThread().suspend();
  40.             }
  42.             //模拟1s
  43.             try {
  45.                 Thread.sleep(1000);
  47.             } catch (InterruptedException e) {
  49.                 e.printStackTrace();
  50.             }
  52.         }
  54.         System.out.println(Thread.currentThread().getName()+"跑完了全程，兔子比赛失败！");
  55.     }
  56. }
  2. public class To extends Thread {
  3.     private String name;
  5.     private Rb rabbit;
  7.     public To(String name, Rb rabbit) {
  9.         //给线程起名字
  10.         super(name);
  12.         this.name = name;
  13.         this.rabbit = rabbit;
  14.     }
  16.     /**
  17.      * 唤醒兔子的方法
  18.      */
  19.     public void hxRabbit(){
  21.         System.out.println(Thread.currentThread().getName()+"唤醒了"+ rabbit.getName());
  23.         rabbit.resume();
  24.     }
  26.     @Override
  27.     public void run() {
  29.         for (int i = 0; i <= 950 ; i+=50) {
  31.             System.out.println(Thread.currentThread().getName()+"跑了"+(i + 50)+"米");
  33.             //模拟1s
  34.             try {
  36.                 Thread.sleep(1000);
  38.             } catch (InterruptedException e) {
  40.                 e.printStackTrace();
  41.             }
  43.         }
  45.         //乌龟要唤醒兔子
  46.         hxRabbit();
  47.         System.out.println(Thread.currentThread().getName()+"跑完了全程，乌龟取得了胜利！");
  48.     }
  49. }

五、线程安全

5.1 线程不安全发生的条件
  1. 多线程的并发；
  2. 有共享的数据；
  3. 共享数据有修改的行为；

5.2 处理线程安全问题

1. 线程同步锁synchronized三种用法

synchronized (共享对象){}里面的共享对象一定要是所有参与同步的线程共同的对象。

第一种:同步代码块 仅锁住想锁住的内容。 synchronized(线程共享对象){ 同步代码块: }

第二种:在实例方法上使用synchronized 必须所著整个方法的内容。实例方法中加锁是共享方法。

第三种:在静态方法上使用synchronized 静态方法中的synchronized锁是类级别的锁属于共享类。

2. 线程同步

安全问题应当优先考虑，效率其次。

  1. 异步编程模型

线程A和线程B，各自执行各自的，A不管B，B不管A,谁也不需
要等谁，这种编程模型叫做:异步编程模型。其实就是:多线程
并发效率较高

  1. 同步编程模型

线程A和线程B，在线程A执行的时候，必须等待B线程执行结束，或
者说在A线程执行的时候，必须等待B线程执行结束，两个线程之间
发生了等待关系，这就是同步程模型。效率较低。

  1. 线程同步时使用案例
    1.     假设有张三线程和李四线程同时并发执行程序，this指的是当前的账户实例，如果张三线程和李四线程同时来执行取款的操作，那么这个两个线程会取争夺this对象锁，如果张三先抢到，那么张三先进入代码块去执行代码，这个时候，李四线程只能在锁池中进行等待。必须要等张三线程执行完之后，李四线程才能重新获取对象锁，进入代码块执行代码！哪个线程拥有对象锁，该线程就拥有了进入代码块执行代码的权力
  1. public class Account {
  3.     //持卡人姓名
  4.     private String accountName;
  6.     private double balance;
  8.     public Account(String accountName, double balance) {
  9.         this.accountName = accountName;
  10.         this.balance = balance;
  11.     }
  13.     public void getMoney(double money){
  15.        //使用synchronized将需要同步的方法内的代码块扩起来。
  16.         synchronized (this){
  17.         //this指的是当前调用改方法的对象。是对改对象的同步操作；
  18.             //获取当前账户的余额
  19.             double balance = this.getBalance();
  22.             try {
  23.                 //模拟网络延迟
  24.                 Thread.sleep(1000);
  25.             } catch (InterruptedException e) {
  27.                 e.printStackTrace();
  28.             }
  29.             //在当前的余额基础上进行扣款
  30.             this.setBalance(balance - money);
  31.         }
  33.         System.out.println(Thread.currentThread().getName()+"取走了"+money+"元,账户剩余"+this.getBalance());
  35.     }
  36. }

六、赛跑案例二

需求如下

  1. 龟兔赛跑：
  2. 场景如下。兔子、乌龟和公鸡进行赛跑，其中兔子每秒0.5米的速度，每跑2米休息10秒；乌龟每秒跑0.1米，
  3. 不休息；公鸡每秒0.8米，每跑3秒需要吃一条虫子，耗时0.6秒。   当其中一个跑到终点后其他动物就不跑了；
  4. 比赛道路长20米。试用多线程模拟该比赛过程。
  5. 1、创建工程。
  6. 2、使用继承技术，创建动物类，乌龟、兔子和公鸡需要从该类继承
  7. 3、时刻记录每个动物当前共计跑了多少米，用控制台输出
  8. 4、使用集合对象存储三个动物
  9. 5、其中一个到达终点后，其他动物停止跑动。
  10. 6、时刻记录三个动物一共跑了多少米，需要解决并发问题。
  11. 7、创建主函数启动该模拟过程。

案例设计思路：

  • 创建动物类（作为父类）继承Thread类。

    1.   动物父类定义名字、速度、赛道长度名称等，并创建父类构造来给不同子<br />类继承以实现多态，封装各方法。

  • 分别编辑子类。

每个动物类继承父类（相当于也继承了Thread类），聚合另外两个动物
类的对象（由于需要在本类结束时关停其余两个线程）。写本类构造方法
但是要super指向父类。构造方法不需要写入其余两类聚合对象，之后用
set方法赋值来解决。
在重写的run方法中写入每个线程运作的逻辑，注意本线程如果结束判断
其余线程是否存活，存活则关闭。

  • 代码省略；

七、守护线程

  1. 守护线程一般属于后台线程，用户线程一旦结束，守护线程也会跟着结束。
  2. 守护线程一般是一个死循环，会守护用户线程。

  3. 守护线程的操作

    1. thread.setDaemon(true);
    2. thread.start;

  4. 垃圾回收线程（守护线程） ： 定时的去回收资源

  5. 主线程 ：其实就是主函数 是由jvm直接调用的线程

八、案例三：生产者消费者

8.1 Object类中的wait和notify方法
  1. wait()让正在该对象上活动的线程进入等待状态，无期限等待，直到被唤醒为止。wait)方法的调用，会让正在改对象的当前线程进入等待状态
  2. notify()方法作用只会随机选取一个处于等待池中的线程进入锁池去竞争获取锁的机会
  3. notifyAll:会让所有处于等待池的线程全部进入锁池去竞争获取锁的机会
  4. wait于notify必须要先加锁，必须在线程同步的条件下才能实现。
    8.2案例需求：生产者生产了一共产品，消费者就要去消费。
    实现代码如下：比较简单 ```java import java.util.HashMap; import java.util.List;

public class test01 {

} //存放产品的类 class House{ private List list;

  1. public House(List list) {
  2.     this.list = list;
  3. }
  5. public List getList() {
  6.     return list;
  7. }
  9. public void setList(List list) {
  10.     this.list = list;
  11. }

} //生产者类 class thread01 extends Thread{ private House house;

  1. public thread01(House house) {
  2.     this.house = house;
  3. }
  5. @Override
  6. public void run() {
  7.     int i = 10;
  8.     while(i>0){
  9.         synchronized (house){
  10.          if(house.getList().size()>0){
  11.              try {
  12.                  this.house.wait();
  13.              } catch (InterruptedException e) {
  14.                  e.printStackTrace();
  15.              }
  16.          }
  18.              house.getList().add(new Object());
  19.              System.out.println(Thread.currentThread().getName()+"生产了产品为："+this.house.getList().get(0));
  21.             try {
  22.                 Thread.sleep(200);
  23.             } catch (InterruptedException e) {
  24.                 e.printStackTrace();
  25.             }
  26.             this.house.notifyAll();
  27.         }
  28.         i--;
  29.     }
  30. }

}

class thread02 extends Thread{ private House house;

  1. public thread02(House house) {
  2.     this.house = house;
  3. }
  5. @Override
  6. public void run() {
  7.     int j = 10;
  8.     while(j>0){
  9.         synchronized (house){
  10.             if(house.getList().size()==0){
  11.                 try {
  12.                     this.house.wait();
  13.                 } catch (InterruptedException e) {
  14.                     e.printStackTrace();
  15.                 }
  16.             }
  18.                 Object object =  house.getList().remove(0);
  19.              //注意这个地方不能和生产者一致，由于以及在上一步移除（消费）了共享区域中数据，没办法直接通过list读取。
  20.                 System.out.println(Thread.currentThread().getName()+"消费了产品为："+object);
  22.             try {
  23.                 Thread.sleep(200);
  24.             } catch (InterruptedException e) {
  25.                 e.printStackTrace();
  26.             }
  27.             this.house.notifyAll();
  28.         }
  29.         j--;
  30.     }
  31. }

}

  2. ```java
  3. public class test02 {
  4.     public static void main(String[] args) {
  5.         House house = new House(new ArrayList());
  6.         thread01 thread01 = new thread01(house);
  7.         thread02 thread02 = new thread02(house);
  8.         thread01.setName("生产者");
  9.         thread02.setName("消费者");
  10.         thread01.start();
  11.         thread02.start();
  12.     }
  13. }

image.png