Java 线程二刷总结

---

线程创建

Thraed , Runnable , Callable

• 继承Thread类(重点)
• 实现Runnable接口(重点 推荐使用)
• 实现Callable接口 (了解就行)

1. 继承Thread类
   

2. 实现Runnable接口

可以Lambda优化

小结

• 继承Thread类
  • 子类继承Thread类具备多线程能力
  • 启动线程： 子类对象.start();
  • 不建议使用： 避免OOP单继承局限性
• 实现Runnable接口
  • 实现接口Runnable接口具有多线程能力
  • 启动线程： 传入目标对象+Thread对象.start();
  • 推荐使用： 避免单继承局限性，灵活方便，方便同一个对象被多个线程使用

3. 实现Callable接口

---

线程的五种状态

创建状态、就绪状态、运行状态、阻塞状态、死亡状态 五种情况

什么情况下会变换情况

---

线程方法

—

停止线程

• 不推荐使用JDK提供的stop(),destory()方法【已废弃】
• 推荐让线程自己停下来
• 建议使用一个标志位进行终止变量当flag=false，则终止线程运行

public class ThreadStop implements Runnable{
    // 1. 设置一个标识位
    private boolean flag = true;

    @Override
    public void run() {
        int i = 0;
        while(flag){
            System.out.println("run....Thread"+i++);
        }
    }

    // 2. 设置一个公开的方法停止线程，线程标志位
    public void stop(){
        this.flag = false;
    }

    public static void main(String[] args) {
        ThreadStop threadStop = new ThreadStop();
        new Thread(threadStop).start();

        for (int i = 0; i < 1000; i++) {
            System.out.println("主线程执行中");
            if(i==900){
                // 调用stop方法切换标志位，让线程停止
                threadStop.stop();
                System.out.println("线程该停止了");
            }
        }
    }
}

线程休眠

• sleep (时间) 指定当前线程堵塞的毫秒数
• sleep存在异常InterruptedException;
• sleep事件达到后线程进入就绪状态
• sleep可以模拟网络延时，倒计时等。
• 每一个对象都有一个锁，sleep不会释放锁。

线程礼让

• 礼让线程，让当前正在执行的线程暂停，但不阻塞
• 将线程从运行状态转为就绪状态
• 让CPU重新调度，礼让不一定成功！看CPU心情

线程强制执行

主线程 被 插队。

---

线程观察状态

## thread.getState() ##

* NEW 尚未启动的线程处于此状态
* RUNNABLE 在java虚拟机中执行的线程处于此状态
* BLOCKED 被堵塞等待监视器锁定的线程处于此状态
* WAITING 正在等待另一个线程执行特定的动作达到指定等待时间的线程处于此状态
* TERMINATED 已退出的线程处于此状态

线程优先级

java 提供一个线程调度器来监控程序中启动后进入就绪状态的所有线程，线程调度器按照优先级决定应该调度哪个线程来执行。

线程的优先级用数字表示范围： 1~10

• Thread.MIN_PRIORITY = 1;
• Thread.MAX_PRIORITY = 10;
• Thread.NORM_PRIORITY = 5;

使用以下方式改变或获取优先级

• getPrioirty() 和 .setPrioirty(int xxx)

先设置优先级 再启动

---

守护线程

• 线程分为用户线程和守护线程
• 虚拟机必须确保用户线程执行完毕
• 虚拟机不用等待守护线程执行完毕
• 如… 后台记录操作日志、监控内存、垃圾回收等等。

设置守护线程
把Thread对象设置.setDaemon(true);默认false表示是用户线程，正常的线程都是用户线程。

---

线程锁

synchronized 隐式的

1.  一个线程持有锁会导致其他所有需要此锁的线程挂起
2.  在多线程竞争下，加锁，释放锁会导致比较多的上下文切换和调度延时，引起性能问题
3. 一个优先级高的等待一个优先级低 的 线程释放锁，会导致优先级倒置，引起性能问题

锁run方法或者锁对象

同步块 synchronized(Obj){ 内容 }

Obj称之为同步监视器，可以是任何对象。

锁run方法，run方法的this是银行，但是操作的是账户，所以 锁run方法不可以。

👇👇👇👇👇
Code跳转链接

取钱的时候，你和她操作一个账户，所以锁账户对象可以

👇👇👇👇👇
eg: 2 锁List对象                                                                                 👇👇
另外 List有本身就安全的new CopyOnWriteArrayList<类型>(); 可以直接使用

---

死锁

某一个同步块同时拥有“两个以上对象的锁”时，就可能会发生“死锁”的问题。

产生死锁的四个必要条件

1. 互斥条件： 一个资源每次只能被一个进程使用
2. 请求与保持条件： 一个进程因请求资源而堵塞时，对已获得的资源保持不放。
3. 不剥夺条件：进程以获得的资源，在未使用完之前，不能强行剥夺。
4. 循环等待条件：若干进程之间形成一种头尾相接的循环等待资源关系。

这四个必要条件，只需要破开其中1~多个就能避免死锁发生

// 当一个人获得口红之后 想要镜子，但不会释放口红。所以会发生死锁
// 解决办法：把第二个锁写到外面
if(choice == 0){  // 防止老贪逼
     synchronized (lipstick){ // 获得口红的锁
          System.out.println(this.girlNmae+"获得口红的锁");
          Thread.sleep(1000);
          synchronized (mirror){   // 获得镜子的锁
              System.out.println(this.girlNmae+"获得镜子的锁");
          }
     }
}else{
    synchronized (mirror){
          System.out.println(this.girlNmae+"获得镜子的锁");
          Thread.sleep(1000);
          synchronized (lipstick){
              System.out.println(this.girlNmae+"获得口红的锁");
          }
    }
}

👇👇👇👇👇
解决后的例子

---

Lock锁

Lock是显式锁（手动开启和关闭）

• Lock只有代码块锁，synchronized有代码块锁和方法锁
• 使用Lock锁，JVM将花费较少的事件来调度线程，性能更好。拓展性更好（提供更多的子类）.
• 优先使用顺序： Lock > 同步代码块（已经进入了方法体，分配了相应资源）> 同步方法（在方法体之外）

---

线程协作问题

首先是生产者消费模式!

具体含义：

1. 假设仓库内只能存放n件产品，生产者将生产出来的产品放入仓库，消费者从仓库中取走消费。
2. 如果仓库中没有商品，则生产者将产品放入仓库，否则停止生产等待，直到仓库中的产品被消费者取走为止。
3. 如果仓库中有物品，则消费者可以取走消费，否则停止消费并等待，直到仓库再次放入产品为止。

思路：synchronized不能用来实现不同线程之间的消息传递！！！

• java中提供了以下方法解决线程之间通信的问题

方法名	作用
wait()	表示线程一直等待，知道其他线程通知，与sleep不同，会释放锁
wait(long timeout)	指定等待的毫秒数
notify()	唤醒一个处于等待状态的线程
notifyAll()	唤醒同一个对象上所有调用wait()方法的线程，优先级别高的线程优先调度

注意：均是Object类的方法，都只能在同步方法或者同步代码块中使用，否则会抛出异常IIIegalMonitorStateExceotion

---

解决方式1： 管程法

具体实现： 除了消费者和生产者类之外，设置一个缓冲区类，消费者不直接使用生产者的数据，他们共同使用这个“缓冲区”

👇👇👇👇👇
Code看这里

解决方式2：信号灯法

具体实现：就是上面的标识位思想

👇👇👇👇👇

Code看这里

---

线程池

由于线程总是需要创建和销毁，进而使用大量的资源，在高并发情况下，对性能影响很大。

思路： 提前创建多个线程，放入线程池中，使用时直接获取，避免重复创建和销毁，实现重复利用。

好处：

1. 提高响应速度（节约创建的时间）
2. 降低资源消耗（重复利用线程池中的线程，不需要每次都创建）
3. 便于线程管理
   • corePoolSize: 核心池的大小
   • maximumPoolSize: 最大线程数
   • keepAliveTime: 线程没有任务时最多保持多长时间后会终止

接口：ExecutorService和Executors

---

import java.util.concurrent.Executor;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class TestPool {
    public static void main(String[] args) {
        // 1, 创建线程池
        ExecutorService service = Executors.newFixedThreadPool(10);  // 大小10
        // 执行
        service.execute(new MyThread());
        service.execute(new MyThread());
        service.execute(new MyThread());
        service.execute(new MyThread());

        // 2. 关闭链接
        service.shutdown();
    }
}

class MyThread implements Runnable{
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName());
    }
}

---

点个赞？