Java多线程从创建到使用完整详细笔记（附各类实现片段）

最新推荐文章于 2021-11-11 08:37:38 发布
最新推荐文章于 2021-11-11 08:37:38 发布
阅读量414 收藏 2
点赞数 1
文章标签： java 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_38377803/article/details/105480629
版权

本篇学习笔记总结自bilibiliup主【狂神说】系列视频：【狂神说Java】多线程详解
视频作者公众号：狂神说

1、线程创建

  1. Thread class --> 继承Thread类
  2. Runnable interface --> 实现Runnable接口
  3. Callable接口 --> 实现Callable接口

1.1、Thread类

1.1.1、实现步骤

  1. 自定义线程继承Thread类
  2. 重写run()方法
  3. 创建线程对象，调用start()方法启动线程

1.2.2、案例

  • Thread类已经实现Runnable接口

    // 继承Thread类，重写run方法，调用start开启
// 线程开启不一定立即执行，由CPU调度执行
public class TestThread01 extends Thread {
    @Override
    public void run() {
        super.run();
        for (int i = 0 ; i < 20 ; i ++){
            System.out.println("使用线程---" + i);
        }
    }

    //main线程为主线程
    public static void main(String[] args) {

        //创建线程对象，调用start方法开启线程
        TestThread01 thread01 = new TestThread01();
        thread01.start();

        for (int i = 0 ; i < 20 ; i ++){
            System.out.println("使用main主线程---" + i);
        }
    }
}

  • 多线程下载图

    import java.io.IOException;
import java.net.URL;


//练习Thread，实现一个多线程同步下载图片
public class TestThread02 extends Thread{

    private String url; //网络我图片地址
    private String FileName;   //保存的文件名

    public TestThread02(String url, String FileName){
        this.url = url;
        this.FileName = FileName;
    }
    
    //下载图片线程的执行体
    @Override
    public void run() {
        super.run();
        WebDownloader webDownloader = new WebDownloader();
        try {
            webDownloader.downloader(url,FileName);
            System.out.println("下载的文件名：" + FileName);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {
        TestThread02 testThread01 = new TestThread02("https://www.baidu.com/img/baidu_jgylogo3.gif","copy1.png");
        TestThread02 testThread02 = new TestThread02("https://www.baidu.com/img/baidu_resultlogo@2.png","copy2.png");
        TestThread02 testThread03 = new TestThread02("https://www.baidu.com/img/bd_logo1.png","copy3.png");

        //理想状态是先下载t1，最后t2，最后t3
        //实质上是几乎同时执行，不一定是这个顺序
        testThread01.start();
        testThread02.start();
        testThread03.start();
    }
}

//下载器
class WebDownloader{
    //下载方法
    public void downloader(String url,String fileName) throws Exception {
        try {
            //came from commons.io.FileUtils
            FileUtils.copyURLToFile(new URL(url), new File(fileName));
        } catch (IOException e) {
            e.printStackTrace();
            System.out.println("IO异常");
        }
    }
}

1.2、Runnable接口

1.2.1、实现步骤

  1. 定义MyRunnable类实现 Runnable接口
  2. 实现run()方法，编写线程执行体
  3. 创建线程对象new Thread()，调用start()方法

1.2.2、案例

//创建线程方式2：实现Runnable接口，重写Run方法。 执行线程需要丢入runnable接口实现类，调用start方法
public class TestThread03 implements Runnable{

    @Override
    public void run() {
        for (int i = 0 ; i < 20 ; i ++){
            System.out.println("使用线程---" + i);
        }
    }
    //main线程为主线程
    public static void main(String[] args) {
        //创建Runnable接口的实现类对象
        TestThread03 thread03 = new TestThread03();
        //创建线程对象，通过线程对象来开启我们的线程。代理
        new Thread(thread03).start();
        for (int i = 0 ; i < 20 ; i ++){
            System.out.println("使用main主线程---" + i);
        }
    }
}

1.3、小结

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

1.4、综合案例

1.4.1、买火车票

//多个线程同时操作同一个对象
//买火车票 有并发问题
public class TestThread04 implements Runnable {
    //票数
    private int ticketNum = 100;
    @Override
    public void run() {
        //Thread.currentThread().getName() ：返回当前线程的名字
        while (ticketNum > 0) {
            //模拟延时20ms
            try {
                Thread.sleep(20);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "-->拿到了倒数第" + ticketNum-- + "票");
        }
    }
    public static void main(String[] args) {
        TestThread04 t1 = new TestThread04();
        TestThread04 t2 = new TestThread04();
        TestThread04 t3 = new TestThread04();
        new Thread(t1,"张三").start();
        new Thread(t2,"罗翔").start();
        new Thread(t3,"黄牛党").start();
    }
}

1.4.2、龟兔赛跑

游戏规则：

  1. 首先初始化赛道距离，每个选手距离赛道越来越近
  2. 判断比赛是否结束
  3. 打印出胜利者
  4. 龟兔赛跑开始
  5. 故事中乌龟胜利，所以要模拟兔子睡觉
  6. 乌龟胜利

代码：

public class Race implements Runnable {
    //胜利者
    private static String winner;

    @Override
    public void run() {
        for (int i = 0; i <= 100; i++) {
            // 模拟兔子睡觉
            if(Thread.currentThread().getName().equals("兔子")){
                try {
                    Thread.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            //判断比赛是否结束
            boolean hasWinner = gameOver(i);
            if (hasWinner){
                break;
            }
            System.out.println(Thread.currentThread().getName() + "跑了" + i + "步");
        }
    }
    //判断是否完成比赛
    private boolean gameOver(int steps){
        if(winner != null){
            System.out.println("已经存在胜利者");
            return true;
        }else {
            if(steps >= 100){
                winner = Thread.currentThread().getName();
                System.out.println("winner is + " + winner);
                return true;
            }else {
                return false;
            }
        }
    }

    public static void main(String[] args) {
        Race race = new Race();
        new Thread(race,"兔子").start();
        new Thread(race,"乌龟").start();
    }
}

1.5、Callable接口

1.5.1、实现步骤

  1. 实现Callable接口，需要返回值类型
  2. 重写call()方法，需要抛出异常
  3. 创建目标对象
  4. 创建执行服务：ExecutorService ser = Executors.newFiexedThreadPool(1);
  5. 提交执行：Future<Boolean> result1 = ser.submit(t1);
  6. 获取结果：boolean r1 = result1.get(1);
  7. 关闭服务：ser.shutdownNow();

1.5.2、优点

  • 可以有返回值
  • 可以抛出异常
  • 关于并发编程的

1.5.3、案例

/**
 *Callable<Boolean>表示接口需要实现的Call()方法返回值类型
 */
public class TestCallable01 implements Callable<Boolean> {

    private String url; //网络我图片地址
    private String FileName;   //保存的文件名

    public TestCallable01(String url, String FileName){
        this.url = url;
        this.FileName = FileName;
    }

    //下载图片线程的执行体
    @Override
    public Boolean call() throws Exception {
        WebDownloader webDownloader = new WebDownloader();
        try {
            webDownloader.downloader(url,FileName);
            System.out.println("下载的文件名：" + FileName);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return true;
    }

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        TestCallable01 t1 = new TestCallable01("https://www.baidu.com/img/baidu_jgylogo3.gif","copy1.png");
        TestCallable01 t2 = new TestCallable01("https://www.baidu.com/img/baidu_resultlogo@2.png","copy2.png");
        TestCallable01 t3 = new TestCallable01("https://www.baidu.com/img/bd_logo1.png","copy3.png");

        //1：创建执行服务：
        //param: 有创建三个线程
        ExecutorService ser = Executors.newFixedThreadPool(3);
        //2：提交执行
        Future<Boolean> r1 = ser.submit(t1);
        Future<Boolean> r2 = ser.submit(t2);
        Future<Boolean> r3 = ser.submit(t3);
        //3：获取结果
        boolean rs1 = r1.get();
        boolean rs2 = r2.get();
        boolean rs3 = r3.get();

        System.out.println(rs1);
        System.out.println(rs2);
        System.out.println(rs3);
        //4：关闭服务
        ser.shutdown();
    }
}

2、线程使用

2.1、静态代理

2.1.1、概念

  • 真实对象和代理对象都要实现同一个接口
  • 代理对象要代理真实角色

2.1.2、概念

  • 代理对象可以做很多真实对象做不了的事情
  • 真实对象专注做自己的事

2.1.3、案例

  • 你：真实的角色
  • 婚庆公司：代理你，帮你处理结婚的事
  • 结婚：实现结婚接口
public class StaticProxy {
    public static void main(String[] args) {
        WeddingProxy weddingProxy = new WeddingProxy(new You());
        weddingProxy.HappyMarry();
    }
}
interface Marry {
    void HappyMarry();
}
//真实角色
class You implements Marry {
    @Override
    public void HappyMarry() {
        System.out.println("你结婚了");
    }
}
//代理角色
class WeddingProxy implements Marry {
    //代理目标对象
    private Marry client;
    public WeddingProxy(Marry client) {
        this.client = client;
    }
    @Override
    public void HappyMarry() {
        before();
        this.client.HappyMarry(); //这是真实对象
        after();
    }
    private void after() {
        System.out.println("结婚之后洞房花烛");
    }
    private void before() {
        System.out.println("结婚之前布置会场");
    }
}

在线程中，Thread类其实是代理类，实现了Runnable里面的run()方法

new Thread(()-> System.out.println("我爱你")).start();
new WeddingProxy(new You()).HappyMarry();

2.2、Lamdba表达式

2.2.1、概述

为什么要使用Lamdba表达式

  • 避免匿名内部类定义过多
  • 让代码看起来比较简洁

例如：

new Thread(()-> System.out.println("我爱你")).start();

如何理解？

  • 理解Functional Interface(函数式接口) 是学习Java8 lamdba表达式的关键所在

  • 函数式接口：

    • 任何接口，如果只包含一个抽象方法，这个接口就是函数式接口：

      例如：

      public interface Runnable{
  public abstract void run();
}

    • 对于任何函数式接口，我们可以通过lamdba表达式创建该接口的对象

2.2.2、案例

public class TestLamda02 {
    public static void main(String[] args) {
      
        Ilove love1 = null;
        Ilove love2 = null;
        Ilove love3 = null;
        Ilove love4 = null;
        //标准Lambda用法
        love1 = (String name)->{
            System.out.println("I love you + " + name);
        };
        
        //简化1：如果参数类型与接口一样，去掉参数类型
        love2 = (name)->{
            System.out.println("I love you + " + name);
        };
        
        //简化2：简化括号，多个参数必须要括号
        love3 = name -> {
            System.out.println("I love you + " + name);
        };

        //简化3：去掉花括号{需要代码只有一行}
        love4 = name-> System.out.println("I love you + " + name);

        love1.SayLove("咬人猫1");
        love2.SayLove("咬人猫2");
        love3.SayLove("咬人猫3");
        love4.SayLove("咬人猫4");

    }
}
interface Ilove{
    void SayLove(String name);
}

2.2、线程基本概念

2.2.1、线程状态

此章节转载总结自https://blog.csdn.net/qq_22771739/article/details/82529874

在这里插入图片描述

  1. 初始(NEW)：新创建了一个线程对象，但还没有调用start()方法。一个线程new出来，线程就进入了初始状态。
  2. 运行中(RUNNABLE)：Java线程中将就绪（ready）和运行中（running）两种状态笼统的称为“运行”。
    • 就绪（ready）：
      • 就绪状态只是说你资格运行，调度程序没有挑选到你，你就永远是就绪状态。
      • 调用线程的start()方法，此线程进入就绪状态。
      • 当前线程sleep()方法结束，其他线程join()结束，等待用户输入完毕，某个线程拿到对象锁，这些线程也将进入就绪状态。
      • 当前线程时间片用完了，调用当前线程的yield()方法，当前线程进入就绪状态。
      • 锁池里的线程拿到对象锁后，进入就绪状态。
    • 运行中（running）：
      • 线程调度程序从可运行池中选择一个线程作为当前线程时线程所处的状态。这也是线程进入运行状态的唯一一种方式。
  3. 阻塞(BLOCKED)：阻塞状态是线程阻塞在进入synchronized关键字修饰的方法或代码块(获取锁)时的状态。
  4. 等待(WAITING)：进入该状态的线程需要等待其他线程做出一些特定动作（通知或中断）。处于这种状态的线程不会被分配CPU执行时间，它们要等待被显式地唤醒，否则会处于无限期等待的状态。
  5. 超时等待(TIMED_WAITING)：处于这种状态的线程不会被分配CPU执行时间，不过无须无限期等待被其他线程显示地唤醒，在达到一定时间后它们会自动唤醒。
  6. 终止(TERMINATE)：表示该线程已经执行完毕。

2.2.2、线程主要方法

setPriority(int newPriority) ：更改线程优先级

static void sleep(long millis) ：在指定毫米内让线程休眠

void join()：等待该线程停止

static void yield()： 暂停当前线程对象，并执行其他线程

void interrupt(): 中断线程，慎用

boolean isAlive()： 测试线程是否在活动状态

2.2.3、停止线程

  • 不推荐使用JDK使用的stop() destory() 方法
  • 推荐让线程自己停下来
  • 建议使用一个标志位进行种植变量 当flag = false 线程终止
public class TestStop implements Runable{
  private boolean runThread = true;
  
  @Override
  public void run(){
    while (runThread){
      System.out.printin("run..."){      
      }
    }
  }
  //对外部提供方法改变标识
  public void stop(){
    this.runThread = false;
  }
}

2.2.4、线程休眠

  • sleep()时间到达之后进入就绪状态
  • 每个对象都有一个锁，sleep() 不会释放锁

2.2.5、线程礼让

static void yield()

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

2.2.6、线程强制执行

void join()

  • join()合并线程，待此线程执行完成后，再执行其他线程。
  • 其他线程会被阻塞，直到该线程完全执行完（慎用，会造成其他线程阻塞）
  • 可以想象成插队

2.2.7、线程状态观测

Thread.State记录线程状态

线程状态可以出于以下状态之一：

  • New：尚未启动的线程处于此状态
  • Runnable：在Java虚拟机中执行的线程处于此状态
  • Blocked：被阻塞等待监视器锁定的线程处于此状态
  • Waiting：正在等待另一个线程执行特定动作的线程处于此状态
  • Timed_Waiting：正在等待另一个线程执行动作达到指定等待时间的线程处于此状态
  • Terminated：已经退出的线程处于此状态

2.2.8、线程优先级

  • Java提供一个线程调度器来监控程序启动后进入就绪的所有线程，调度器按照优先级决定哪个线程应该被执行
  • 需要设置优先级再启动
  • 优先级用数字表示，从1～10
    • Thread.MIN_PRIORITY = 1
    • Thread.MAX_PRIORIY = 10
    • Thread.NORM_PRIORIY = 5
  • 使用以下方法改变或者获取优先级
    • getPriority()
    • setPriority(int level)
  • 优先级高的不一定先执行，一切看CPU调（xin）度（qing），有可能导致性能倒置

2.2.9、守护线程

  • 线程分为用户线程和守护(daemon)线程
  • 虚拟机必须要保证用户线程执行完毕
  • 虚拟机不用等待守护线程执行完毕
  • 如，后台记录操作日志，监控内存，垃圾回收（GC）

3、线程同步

  • 处理多线程问题时，多个线程访问同一个对象，并且某些线程还想修改这个对象，这个时候需要用到线程同步。
  • 线程同步是一种等待机制，多个需要同时访问此对象的线程进入这个对象的等待池形成队列，前面的使用完毕，下一个线程再使用
  • 线程同步执行条件：队列 + 锁（同时也是synchronized关键字的实现原理）
  • 可以使用JUC包实现线程安全

3.1、锁机制

3.1.1、基本概念

  • 关键字synchronized：当一个线程获得对象的排它锁，独占资源，其他线程必须等待，使用完成释放锁即可
  • 每个对象都有一把锁，每个synchronized方法都必须获得调用该方法的对象的锁才能执行，否则线程阻塞。方法一旦执行，独占该锁，知道该方法返回才释放锁，后面被阻塞的线程才能获得这个锁，继续执行。

存在以下问题

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

3.1.2、案例

import java.util.ArrayList;
import java.util.List;

//线程不安全的集合
public class UnsafeList {
    public static void main(String[] args) throws InterruptedException {
        // ArrayList线程不安全（两个线程把添加到了同一个位置，所以覆盖掉了，最后总数会少）
        List<String> list = new ArrayList<String>();
        for (int i = 0; i < 10000; i++) {
            new Thread(()->{
                synchronized (list){
                list.add(Thread.currentThread().getName());
                }
            }).start();
        }
        Thread.sleep(1000);
        System.out.println(list.size());
    }
}

3.2、死锁

3.2.1、概念

  • 多个线程各自占用一些共享资源，导致两个或者多个线程都在等待对方释放资源，造成死锁
  • 某一个同步块同时拥有两个以上对象的锁时，就可能发生死锁问题

3.2.2、死锁案例

public class TestDeadlock {
    public static void main(String[] args) {
        makeup makeup = new makeup("白雪公主",1);
        makeup makeup2 = new makeup("灰菇凉",0);
        makeup.start();
        makeup2.start();
    }
}
class Mirror{

}
class Lipstick{

}
class makeup extends Thread {

    //使用static关键字表示只有一份资源
    static final Mirror mirror = new Mirror();
    static final Lipstick lipstick = new Lipstick();

    String girlName;
    int choice;

    public makeup(String girlName,int choice){
        this.girlName = girlName;
        this.choice = choice;
    }
    @Override
    public void run() {
        super.run();
        try {
            startMakeUp(this.girlName,this.choice);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    private void startMakeUp(String girlName, int choice) throws InterruptedException {
        if(choice == 1){
          //这里一个进程想在获得一个资源的同时获得另外一个资源的权限
            synchronized (mirror){
                System.out.println(girlName + "拿到了镜子");
                Thread.sleep(1000);
                synchronized (lipstick){
                    System.out.println(girlName + "拿到了口红");
                }
            }
        }else{
            synchronized (lipstick){
                System.out.println(girlName + "拿到了口红");
                Thread.sleep(500);
                synchronized (mirror){
                    System.out.println(girlName + "拿到了镜子");
                }
            }
        }
    }
}

3.2.3、死锁的避免方法

产生死锁的四个必要条件：

  • 互斥条件：一个资源每次只能被一个进程使用

  • 请求与保持条件：一个进程因请求资源而阻塞时，对已获得的资源保持不放

  • 不剥夺条件：进程已获得的资源，在没有使用完之前，不能强行剥夺

  • 循环等待条件：若干进程之间形成头尾相接的循环等待资源关系

    想办法破坏上述四个条件的一个或者多个即可避免死锁

3.3、Lock（锁）

3.3.1、基本概念

  • 从JDK5.0开始，Java提供了通过显示定义同步锁对象来实现同步。同步锁用Lock对象充当
  • java.util.concurrent.lock接口是控制多个线程对共享资源进行访问的工具。锁提供了对共享资源的独占访问，每次只能有一个线程对Lock对象加锁，线程开始访问共享资源之前应该获得Lock对象
  • ReentrantLock类实现了Lock，它拥有与synchronized想通的并发性和内存语义，在实现线程安全的控制中，比较常用的是ReentrantLock，可以显式加锁、释放锁

3.3.2、案例

import java.util.concurrent.locks.ReentrantLock;

//测试lock锁
public class TestLock {
    public static void main(String[] args) {
        TestLock2 testLock1 = new TestLock2();

        new Thread(testLock1,"黄牛 ").start();
        new Thread(testLock1,"张三 ").start();
        new Thread(testLock1,"Neil ").start();
    }
}
class TestLock2 implements Runnable{
		int ticketNum =  100;

    //定义Lock锁
    //ReentrantLock 是一个可重入锁
    private final ReentrantLock lock  = new ReentrantLock();
    @Override
    public void run() {
        while (true){
            try{
                lock.lock();//加锁
                if(ticketNum > 0){
                    System.out.println(Thread.currentThread().getName() + ticketNum--);
                }else{
                    break;
                }
            }finally {
                //解锁
                lock.unlock();
            }
        }
    }
}

3.3.3、与synchronized 对比

  • Lock是显示锁（手动开启手动关闭），synchronized是隐式锁，出了作用域自动释放
  • Lock只有代码块锁，synchronized有代码块锁和方法锁
  • 使用Lock锁，JVM将花较少的时间调度线程，性能更好。并且具有更好的扩展性（提供更多子类）
  • 推荐优先使用顺序：
    • lock > 同步代码块（已经进入方法题，分配了相应资源）> 同步方法（在方法体外）

4、线程协作

4.1、生产者消费者问题

4.1.1、问题场景

  • 假设仓库只存放一件物品，生产者将生产出来的产品放入仓库，消费者将仓库中的产品取走消费
  • 如果仓库没有产品，则生产者将产品放入仓库，否则停止生产并且等待，直到仓库中的产品被消费者取走位置
  • 如果仓库中有产品，消费者则可以将产品取走消费，否则停止消费并等待，直到仓库再次放入产品为止

4.2.2、分析

这是一个线程同步问题，生产者和消费者共享一个资源，并且生产者和消费者之间互为依赖，互为条件

  • 对于生产者，没有生产产品前，通知消费者等待，生产产品后，通知消费者消费
  • 对于消费者，消费之后要通知生产者已经结束消费，需要生产新的产品提供消费
  • 在生产者消费者问题中，仅有synchronized是不够的
    • synchronized可阻止并发更新同一个共享资源，实现了同步
    • synchronized不能用来实现线程之间的通讯

4.2.3、相关方法

Java提供了几个方法解决线程通讯问题（）

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

均为Object类方法，都只能在同步方法或代码块中使用，否则会抛出异常

4.2.3、解决方法

  • 并发协作模式“生产者/消费者模式”，俗称管理法

    • 生产者：负责生产数据的模块（可以是方法，对象，线程，进程）

    • 消费者：负责处理数据的模块（可以是方法，对象，线程，进程）

    • 缓冲区：消费者不能直接使用生产者的数据图，他们需要一个缓冲区

      生产者将生产好的数据放入缓冲区，消费者从缓冲区拿出数据

  • 并发协作模型“生产者/消费者模式”，俗称信号灯法

    • 通过设置一个信号灯，如果为True的时候通知消费者消费，如果False进行等待

4.2.4、案例代码

管理法

//测试生产者消费者模型，管理法
//需要生产者，消费者，产品，缓冲区
public class TestPC01 {
    public static void main(String[] args) throws InterruptedException {
        SynContainer synContainer = new SynContainer();
        new Producer(synContainer).start();
        //通过更改这里的值来控制过量生产使其爆满或者使其不够（生产一个消费一个）
        Thread.sleep(100);
        new Consumer(synContainer).start();
    }
}

//生产者
class Producer extends Thread{
    SynContainer synContainer;
    public Producer(SynContainer synContainer){
        this.synContainer = synContainer;
    }

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println("生产了第" + i + "个产品");
            synContainer.push(new Product(i));
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

///消费者
class Consumer extends Thread{
    SynContainer synContainer;
    public Consumer(SynContainer synContainer){
        this.synContainer = synContainer;
    }

    @Override
    public void run() {
        super.run();
        for (int i = 0; i < 100 ; i++) {
            Product consumedProduct = synContainer.pop();
            System.out.println("消费了第" + consumedProduct.id + "个产品");
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

//产品
class Product{
    int id;

    public Product(int id) {
        this.id = id;
    }
}

//缓冲区
class SynContainer{
    //需要一个容器大小
    Product[] products = new Product[10];
    // 容器计数器
    int count = 0;

    //生产者放入产品
    public synchronized void push(Product product){
        //如果容器满了，需要等待消费者消费
        if (count == products.length){
            //通知消费者等待，生产等待
            System.out.println("产品已经满了");
            try {
                //进行等待
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }else {
            //如果没有满，需要放入产品
            products[count] = product;
            count++;
            //可以通知消费者消费了
            this.notifyAll();
        }
    }
    //消费者消费产品

    public synchronized Product pop(){
        //判断能否消费
        if(count==0){
            //等待生产者生产，消费者等待
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return null;
        }else {
            //可以消费
            //吃完了
            count--;
            Product product = products[count];
            this.notifyAll();
            return product;
        }
    }
}

4.2、线程池

4.2.1、基本概念

  • 思路：提前创建好多个线程，放入线程池，使用时直接获取，使用完毕放回池中，可以避免重复频繁创建销毁，实现重复利用。
  • 好处：
    • 提高响应速度（减少创建新线程时间）
    • 降低资源消耗（重复利用线程池中的线程，不需要每次创建）
    • 便于线程管理
      • corePoolSize：核心池大小
      • maxImumPoolSize：最大线程数
      • keepAliveTime：线程没有任务时最多保持多长时间后会终止

4.2.2、使用线程池

  • JDK 5.0 起提供了线程池相关API：ExecutorService和Executors
  • ExecutorService：真正的线程池接口。常见子类ThreadPoolExecutor
    • void execute(Runnable command):执行任务/命令，没有返回值，一般用来执行Runnable
    • <T>Future<T> submit(Callable<T> task):执行任务，有返回值，一般用来执行Callable
    • void shutdown():关闭线程池
  • Executors：工具类、线程池的工厂类，用于创建并返回不同类型的线程池
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class TestPool {
    public static void main(String[] args) {
        //创建线程池
        //newFixedThreadPool参数为线程池大小
        ExecutorService service = Executors.newFixedThreadPool(10);
        //启动
        service.execute(new MyThread());
        service.execute(new MyThread());
        service.execute(new MyThread());
        service.execute(new MyThread());
        //关闭连接
        service.shutdown();

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

参考文献：本篇学习笔记主要总结于bilibili up主 “狂神学Java” 的系列视频— 【狂神说Java】多线程详解

Neillllll^
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
Java多线程学习笔记之sleep()
litlit023的专栏
11-24 238
1. sleep的用途、简单用例 使当前线程睡眠指定的时间，哪个线程调用Thread.sleep则哪个线程就会睡眠（谁调用谁休眠）。睡眠的意思：让出cpu的占用时间 2. sleep注释事项 只针对当前线程，即谁调用sleep()谁就休眠。 睡眠时间并不准确，取决于操作系统的计时器和调度器。 线程调用sleep时不会释放锁：在synchronized块里面进行sleep操作，或已获取锁的线程中执行sleep，该线程不会释放锁。与Object.wait方法不同。 其他线程可中断sleep状态的
java8--新特性CompletableFuture多线程
专搞技术的小兔子
07-13 709
java8新特性CompletableFuture多线程 参考文章: http://javadaily.cn/articles/2021/03/18/1616064645189.html https://www.liaoxuefeng.com/wiki/1252599548343744/1306581182447650 CompletableFuture可以指定异步处理流程： thenAccept()处理正常结果； exceptional()处理异常结果； thenApplyAsync()用于串行化另一个C
线程的基本知识
brimen的博客
03-05 359
1、进程和线程 区别 进程：应用程序的执行实例，有独立的内存空间和系统资源。 线程：CPU调度和分派的基本单位，进程当中执行运算的最小单位，可完成一个独立的顺序控制流程。 联系 （1）、一个线程只能有一个进程，一个进程可以有多个线程。 （2）、资源分配给进程，同一进程当中的所有线程共享该进程的所有资源。 （3）、线程在执行过程当中需要协作同步，不同进程的线程要利用消息通讯的方法实现同步。 2、线程...
多线程实例片段
FlyAir126的博客
12-15 162
/** * * * 下面是部分code， 全部code 见附件 * */ package com.task; /** * 线程模板 实现线程的暂停和恢复 * * 全部code 见附件 * */ public abstract class TemplateThread implements Runnable { /** * 线程状...
java中如何实现多线程操作,写一个多线程的片段.
ah_hzy的博客
06-22 844
1:继承Thread类 package cn.mld //java中实现多线程的类，继承Thread类(java.lang.Thread) public class MyThread extends Thread{ private String title; public MyThread(String title) { this.title=title; } @Override ...
多线程程序片段
cjwix2012的专栏
09-25 363
BackgroundWorker _BackgroundWorker = new BackgroundWorker();             _BackgroundWorker.DoWork += (s, e) =>             {                 Console.WriteLine("多线程");             };             _
Java线程学习（一）线程的创建和执行
虚幻（x~huan）的博客
05-04 531
线程的创建和执行开门见山在IT圈里，每当我们谈论并发时，必定会说起在一台计算机上同时运行的一系列线程。如果这台电脑上有多个处理器或者是一个多核处理器，那么这时是实实在在的“同时运行”；但是，如果计算机只有一个单核处理器，那么这时的“同时运行”只是表象而已。所有的现代操作系统全部支持任务的并发执行。你可以边听音乐，边上网看新闻，还不耽误首发电子邮件。我们可以说，这种并发是 进程级并发 。在进程内部，我
java多线程笔记
01-14
它们之间通过调用特定的方法（如`start()`、`sleep()`、`join()`等）进行状态转换，生命周期从创建到结束经历这些状态。 创建与启动线程通常涉及创建`Thread`对象，然后调用`start()`方法。线程名称可以通过`set...
java笔记 java笔记 java笔记
03-15
【标题】：“Java笔记”是Java开发语言的学习记录，涵盖了从基础到高级的全面知识体系。这份笔记旨在帮助开发者深入理解和掌握Java编程的核心概念和技术。 【描述】：这份"Java笔记"来源于网络资源...
并发编程之二：线程创建方法、运行原理、常见方法(sleep,join,interrupt,park,守护线程等)
java_xxxx的博客
11-29 859
线程创建方法、运行原理线程的创建方法继承Thread实现RunnableFutureTask线程的运行原理栈与栈帧线程运行情况线程的上下文切换(Thread Context Switch)线程中的常见方法start与runsleep与yield 线程的创建方法 继承Thread /** Thread */ public static void test1 () { // 创建线程 Thread thread = new Thread("某将"){
线程的创建与执行
自强博客
06-27 615
线程的创建与执行 要点 Thread start() Runnable run() Thread的private void init(ThreadGroup g, Runnable target, String name, long stackSize) Thread与Runnable及start()与run()的结构关系图。 验证start和run的关系 我们先从Thread着手来创建一...
一个对象从加载到创建再到执行的过程（个人理解）
qq_30761967的博客
07-27 292
前面的两个大体上就是先加载再在队中开辟空间用于存放对象。 首先说加载，分为5个步骤： 加载： 首先是类加载器，一般是由AppClassLoader，系统类加载器加载类，此时使用的是双亲委派来实现加载的，其实一开始系统类加载器是不加载类的，是交由父类加载器即扩展类加载器加载的，但是扩展类加载器一般是加载lib下的etc下的jar文件和class文件，所以如果是用户自定义的类的话那么一定不会被这个加载的，那么扩展类加载器会将其交给父类加载器即启动类加载器去加载，但是启动类加载器一般是加载lib下的jre和j
线程执行的主要流程
Hai.Pan的专栏
10-06 690
读书笔记
线程的创建过程
bss13287350062的博客
11-11 852
------------------------继承Thread类创建线程--------------------- 通过继承Thread类来创建并启动多线程的一般步骤如下 1】定义Thread类的子类，并重写该类的run()方法，该方法的方法体就是线程需要完成的任务，run()方法也称为线程执行体。 2】创建Thread子类的实例，也就是创建了线程对象 3】启动线程，即调用线程的start()方法 ------------------------实现Runnable接口创建线程---------
请详细描述一下线程从创建到死亡的几种状态都有哪些？
学亮编程手记
02-05 864
请详细描述一下线程从创建到死亡的几种状态都有哪些？ 新建( new )：新创建了一个线程对象。 可运行( runnable )：线程对象创建后，其他线程(比如 main 线程）调用了该对象的 start ()方法。该状态的线程位于可运行线程池中，等待被线程调度选中，获取 cpu 的使用权 。 运行( running )：可运行状态( runnable )的线程获得了 c...
java线程状态和常用方法解释
madman
05-10 348
文章转自线程的几种状态转换 其他的一些参考链接 java 线程方法join的简单总结 Java并发编程：线程间协作的两种方式：wait、notify、notifyAll和Condition java多线程（八）为什么弃用stop和suspend 线程在一定条件下，状态会发生变化。线程一共有以下几种状态： 1、新建状态(New)：新创建了一个线程对象。 2、就绪状态(Runnable)...
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值