2024年最新21天学习挑战赛之java多线程

2401_84185471

于 2024-05-03 04:02:28 发布

阅读量973

点赞数 8

分类专栏：程序员文章标签： java 学习 python

本文链接：https://blog.csdn.net/2401_84185471/article/details/138406567

版权

程序员专栏收录该内容

112 篇文章 0 订阅

订阅专栏

public static void main(String[] args) throws InterruptedException {

    //定义一个内部线程
    Thread thread = new Thread(() -> {
        System.out.println("2.执行thread.start()之后，线程的状态：" + Thread.currentThread().getState());
        try {
            //休眠100毫秒
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("4.执行Thread.sleep(long)完成之后，线程的状态：" + Thread.currentThread().getState());
    });

    //获取start()之前的状态
    System.out.println("1.通过new初始化一个线程，但是还没有start()之前，线程的状态：" + thread.getState());

    //启动线程
    thread.start();

    //休眠50毫秒
    Thread.sleep(50);

    //因为thread1需要休眠100毫秒，所以在第50毫秒，thread处于sleep状态
    System.out.println("3.执行Thread.sleep(long)时，线程的状态：" + thread.getState());

    //thread1和main线程主动休眠150毫秒，所以在第150毫秒,thread早已执行完毕
    Thread.sleep(100);

    System.out.println("5.线程执行完毕之后，线程的状态：" + thread.getState() + "\n");

}

}


控制台输出

1.通过new初始化一个线程，但是还没有start()之前，线程的状态：NEW
2.执行thread.start()之后，线程的状态：RUNNABLE
3.执行Thread.sleep(long)时，线程的状态：TIMED_WAITING
4.执行Thread.sleep(long)完成之后，线程的状态：RUNNABLE
5.线程执行完毕之后，线程的状态：TERMINATED


#### 


#### 1.3 线程的状态-练习2


**目的 :** 本案例主要演示WAITING的状态转换。


\*\*需求 ：\*\*编写一段代码，依次显示一个线程的这些状态：NEW -> RUNNABLE -> WAITING -> RUNNABLE -> TERMINATED


**代码实现 :**

public class ThreadStateDemo02 {

public static void main(String[] args) throws InterruptedException {

    //定义一个对象，用来加锁和解锁
    Object obj = new Object();

    //定义一个内部线程
    Thread thread1 = new Thread(() -> {
        System.out.println("2.执行thread.start()之后，线程的状态：" + Thread.currentThread().getState());
        synchronized (obj) {
            try {

                //thread1需要休眠100毫秒
                Thread.sleep(100);

                //thread1100毫秒之后，通过wait()方法释放obj对象是锁
                obj.wait();
                
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println("4.被object.notify()方法唤醒之后，线程的状态：" + Thread.currentThread().getState());
    });

    //获取start()之前的状态
    System.out.println("1.通过new初始化一个线程，但是还没有start()之前，线程的状态：" + thread1.getState());

    //启动线程
    thread1.start();

    //main线程休眠150毫秒
    Thread.sleep(150);

    //因为thread1在第100毫秒进入wait等待状态，所以第150秒肯定可以获取其状态
    System.out.println("3.执行object.wait()时，线程的状态：" + thread1.getState());

    //声明另一个线程进行解锁
    new Thread(() -> {
        synchronized (obj) {
            //唤醒等待的线程
            obj.notify();
        }
    }).start();

    //main线程休眠10毫秒等待thread1线程能够苏醒
    Thread.sleep(10);

    //获取thread1运行结束之后的状态
    System.out.println("5.线程执行完毕之后，线程的状态：" + thread1.getState() + "\n");

}

}


控制台输出结果

1.通过new初始化一个线程，但是还没有start()之前，线程的状态：NEW
2.执行thread.start()之后，线程的状态：RUNNABLE
3.执行object.wait()时，线程的状态：WAITING
4.被object.notify()方法唤醒之后，线程的状态：RUNNABLE
5.线程执行完毕之后，线程的状态：TERMINATED


#### 


#### 1.4 线程的状态-练习3


**目的 :** 本案例主要演示BLOCKED的状态转换。


\*\*需求 ：\*\*编写一段代码，依次显示一个线程的这些状态：NEW -> RUNNABLE -> BLOCKED -> RUNNABLE -> TERMINATED

public class ThreadStateDemo03 {

public static void main(String[] args) throws InterruptedException {

    //定义一个对象，用来加锁和解锁
    Object obj2 = new Object();

    //定义一个线程，先抢占了obj2对象的锁
    new Thread(() -> {
        synchronized (obj2) {
            try {
                Thread.sleep(100);              //第一个线程要持有锁100毫秒
                obj2.wait();                          //然后通过wait()方法进行等待状态，并释放obj2的对象锁
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }).start();

    //定义目标线程，获取等待获取obj2的锁
    Thread thread = new Thread(() -> {
        System.out.println("2.执行thread.start()之后，线程的状态：" + Thread.currentThread().getState());
        synchronized (obj2) {
            try {
                Thread.sleep(100);              //thread3要持有对象锁100毫秒
                obj2.notify();                        //然后通过notify()方法唤醒所有在ojb2上等待的线程继续执行后续操作
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println("4.阻塞结束后，线程的状态：" + Thread.currentThread().getState());
    });

    //获取start()之前的状态
    System.out.println("1.通过new初始化一个线程，但是还没有thread.start()之前，线程的状态：" + thread.getState());

    //启动线程
    thread.start();

    //先等100毫秒
    Thread.sleep(50);

    //第一个线程释放锁至少需要100毫秒，所以在第50毫秒时，thread正在因等待obj的对象锁而阻塞
    System.out.println("3.因为等待锁而阻塞时，线程的状态：" + thread.getState());

    //再等300毫秒
    Thread.sleep(300);

    //两个线程的执行时间加上之前等待的50毫秒总共是250毫秒，所以第300毫秒，所有的线程都已经执行完毕
    System.out.println("5.线程执行完毕之后，线程的状态：" + thread.getState());

}

}


**控制台输出结果**

1.通过new初始化一个线程，但是还没有thread.start()之前，线程的状态：NEW
2.执行thread.start()之后，线程的状态：RUNNABLE
3.因为等待锁而阻塞时，线程的状态：BLOCKED
4.阻塞结束后，线程的状态：RUNNABLE
5.线程执行完毕之后，线程的状态：TERMINATED


#### 1.5 线程池-基本原理


**概述 :**


 提到池，大家应该能想到的就是水池。水池就是一个容器，在该容器中存储了很多的水。那么什么是线程池呢？线程池也是可以看做成一个池子，在该池子中存储很多个线程。


线程池存在的意义：


 系统创建一个线程的成本是比较高的，因为它涉及到与操作系统交互，当程序中需要创建大量生存期很短暂的线程时，频繁的创建和销毁线程对系统的资源消耗有可能大于业务处理是对系


 统资源的消耗，这样就有点"舍本逐末"了。针对这一种情况，为了提高性能，我们就可以采用线程池。线程池在启动的时，会创建大量空闲线程，当我们向线程池提交任务的时，线程池就


 会启动一个线程来执行该任务。等待任务执行完毕以后，线程并不会死亡，而是再次返回到线程池中称为空闲状态。等待下一次任务的执行。


**线程池的设计思路 :**


1. 准备一个任务容器
2. 一次性启动多个(2个)消费者线程
3. 刚开始任务容器是空的，所以线程都在wait
4. 直到一个外部线程向这个任务容器中扔了一个"任务"，就会有一个消费者线程被唤醒
5. 这个消费者线程取出"任务"，并且执行这个任务，执行完毕后，继续等待下一次任务的到来


#### 1.6 线程池-Executors默认线程池


概述 : JDK对线程池也进行了相关的实现，在真实企业开发中我们也很少去自定义线程池，而是使用JDK中自带的线程池。


我们可以使用Executors中所提供的**静态**方法来创建线程池


 static ExecutorService newCachedThreadPool() 创建一个默认的线程池  
  static newFixedThreadPool(int nThreads) 创建一个指定最多线程数量的线程池


**代码实现 :**

package com.itheima.mythreadpool;

//static ExecutorService newCachedThreadPool() 创建一个默认的线程池
//static newFixedThreadPool(int nThreads) 创建一个指定最多线程数量的线程池

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

public class MyThreadPoolDemo {
public static void main(String[] args) throws InterruptedException {

    //1,创建一个默认的线程池对象.池子中默认是空的.默认最多可以容纳int类型的最大值.
    ExecutorService executorService = Executors.newCachedThreadPool();
    //Executors --- 可以帮助我们创建线程池对象
    //ExecutorService --- 可以帮助我们控制线程池

    executorService.submit(()->{
        System.out.println(Thread.currentThread().getName() + "在执行了");
    });

    //Thread.sleep(2000);

    executorService.submit(()->{
        System.out.println(Thread.currentThread().getName() + "在执行了");
    });

    executorService.shutdown();
}

}


#### 1.7 线程池-Executors创建指定上限的线程池


**使用Executors中所提供的静态方法来创建线程池**


 static ExecutorService newFixedThreadPool(int nThreads) : 创建一个指定最多线程数量的线程池


**代码实现 :**

package com.itheima.mythreadpool;

//static ExecutorService newFixedThreadPool(int nThreads)
//创建一个指定最多线程数量的线程池

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

public class MyThreadPoolDemo2 {
public static void main(String[] args) {
//参数不是初始值而是最大值
ExecutorService executorService = Executors.newFixedThreadPool(10);

    ThreadPoolExecutor pool = (ThreadPoolExecutor) executorService;
    System.out.println(pool.getPoolSize());//0

    executorService.submit(()->{
        System.out.println(Thread.currentThread().getName() + "在执行了");
    });

    executorService.submit(()->{
        System.out.println(Thread.currentThread().getName() + "在执行了");
    });

    System.out.println(pool.getPoolSize());//2

// executorService.shutdown();
}
}


#### 1.8 线程池-ThreadPoolExecutor


**创建线程池对象 :**


ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(核心线程数量,最大线程数量,空闲线程最大存活时间,任务队列,创建线程工厂,任务的拒绝策略);


**代码实现 :**

package com.itheima.mythreadpool;

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public class MyThreadPoolDemo3 {
// 参数一：核心线程数量
// 参数二：最大线程数
// 参数三：空闲线程最大存活时间
// 参数四：时间单位
// 参数五：任务队列
// 参数六：创建线程工厂
// 参数七：任务的拒绝策略
public static void main(String[] args) {
ThreadPoolExecutor pool = new ThreadPoolExecutor(2,5,2,TimeUnit.SECONDS,new ArrayBlockingQueue<>(10), Executors.defaultThreadFactory(),new ThreadPoolExecutor.AbortPolicy());
pool.submit(new MyRunnable());
pool.submit(new MyRunnable());

    pool.shutdown();
}

}


#### 1.9 线程池-参数详解


![在这里插入图片描述](https://img-blog.csdnimg.cn/d31db53752a64bebb4974e95575100ad.png)

public ThreadPoolExecutor(int corePoolSize,
int maximumPoolSize,
long keepAliveTime,
TimeUnit unit,
BlockingQueue workQueue,
ThreadFactory threadFactory,
RejectedExecutionHandler handler)

corePoolSize：核心线程的最大值，不能小于0
maximumPoolSize：最大线程数，不能小于等于0，maximumPoolSize >= corePoolSize
keepAliveTime：空闲线程最大存活时间,不能小于0
unit：时间单位
workQueue：任务队列，不能为null
threadFactory：创建线程工厂,不能为null
handler：任务的拒绝策略,不能为null


#### 1.10 线程池-非默认任务拒绝策略


RejectedExecutionHandler是jdk提供的一个任务拒绝策略接口，它下面存在4个子类。

ThreadPoolExecutor.AbortPolicy: 丢弃任务并抛出RejectedExecutionException异常。是默认的策略。
ThreadPoolExecutor.DiscardPolicy：丢弃任务，但是不抛出异常这是不推荐的做法。
ThreadPoolExecutor.DiscardOldestPolicy：抛弃队列中等待最久的任务然后把当前任务加入队列中。
ThreadPoolExecutor.CallerRunsPolicy: 调用任务的run()方法绕过线程池直接执行。


注：明确线程池对多可执行的任务数 = 队列容量 + 最大线程数


**案例演示1**：演示ThreadPoolExecutor.AbortPolicy任务处理策略

public class ThreadPoolExecutorDemo01 {

public static void main(String[] args) {

    /\*\*

* 核心线程数量为1 ，最大线程池数量为3, 任务容器的容量为1 ,空闲线程的最大存在时间为20s
*/
ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(1 , 3 , 20 , TimeUnit.SECONDS ,
new ArrayBlockingQueue<>(1) , Executors.defaultThreadFactory() , new ThreadPoolExecutor.AbortPolicy()) ;

    // 提交5个任务，而该线程池最多可以处理4个任务，当我们使用AbortPolicy这个任务处理策略的时候，就会抛出异常
    for(int x = 0 ; x < 5 ; x++) {
        threadPoolExecutor.submit(() -> {
            System.out.println(Thread.currentThread().getName() + "---->> 执行了任务");
        });
    }
}

}


**控制台输出结果**

pool-1-thread-1---->> 执行了任务
pool-1-thread-3---->> 执行了任务
pool-1-thread-2---->> 执行了任务
pool-1-thread-3---->> 执行了任务


控制台报错，仅仅执行了4个任务，有一个任务被丢弃了


**案例演示2**：演示ThreadPoolExecutor.DiscardPolicy任务处理策略

    // 提交5个任务，而该线程池最多可以处理4个任务，当我们使用DiscardPolicy这个任务处理策略的时候，控制台不会报错
    for(int x = 0 ; x < 5 ; x++) {
        threadPoolExecutor.submit(() -> {
            System.out.println(Thread.currentThread().getName() + "---->> 执行了任务");
        });
    }
}

}


**控制台输出结果**

pool-1-thread-1---->> 执行了任务
pool-1-thread-1---->> 执行了任务
pool-1-thread-3---->> 执行了任务
pool-1-thread-2---->> 执行了任务


控制台没有报错，仅仅执行了4个任务，有一个任务被丢弃了


**案例演示3**：演示ThreadPoolExecutor.DiscardOldestPolicy任务处理策略

public class ThreadPoolExecutorDemo02 {
public static void main(String[] args) {
/**
* 核心线程数量为1 ，最大线程池数量为3, 任务容器的容量为1 ,空闲线程的最大存在时间为20s
*/
ThreadPoolExecutor threadPoolExecutor;
threadPoolExecutor = new ThreadPoolExecutor(1 , 3 , 20 , TimeUnit.SECONDS ,
new ArrayBlockingQueue<>(1) , Executors.defaultThreadFactory() , new ThreadPoolExecutor.DiscardOldestPolicy());
// 提交5个任务
for(int x = 0 ; x < 5 ; x++) {
// 定义一个变量，来指定指定当前执行的任务;这个变量需要被final修饰
final int y = x ;
threadPoolExecutor.submit(() -> {
System.out.println(Thread.currentThread().getName() + “---->> 执行了任务” + y);
});
}
}
}


**控制台输出结果**

pool-1-thread-2---->> 执行了任务2
pool-1-thread-1---->> 执行了任务0
pool-1-thread-3---->> 执行了任务3
pool-1-thread-1---->> 执行了任务4


由于任务1在线程池中等待时间最长，因此任务1被丢弃。


**案例演示4**：演示ThreadPoolExecutor.CallerRunsPolicy任务处理策略

public class ThreadPoolExecutorDemo04 {
public static void main(String[] args) {

    /\*\*

* 核心线程数量为1 ，最大线程池数量为3, 任务容器的容量为1 ,空闲线程的最大存在时间为20s
*/
ThreadPoolExecutor threadPoolExecutor;
threadPoolExecutor = new ThreadPoolExecutor(1 , 3 , 20 , TimeUnit.SECONDS ,
new ArrayBlockingQueue<>(1) , Executors.defaultThreadFactory() , new ThreadPoolExecutor.CallerRunsPolicy());

    // 提交5个任务
    for(int x = 0 ; x < 5 ; x++) {
        threadPoolExecutor.submit(() -> {
            System.out.println(Thread.currentThread().getName() + "---->> 执行了任务");
        });
    }
}

}


**控制台输出结果**

pool-1-thread-1---->> 执行了任务
pool-1-thread-3---->> 执行了任务
pool-1-thread-2---->> 执行了任务
pool-1-thread-1---->> 执行了任务
main---->> 执行了任务


通过控制台的输出，我们可以看到次策略没有通过线程池中的线程执行任务，而是直接调用任务的run()方法绕过线程池直接执行。


### 2. 原子性


#### 2.1 volatile-问题


**代码分析 :**