java ThreadPoolExecutor线程池里面可以嵌套多线程吗

转载

mob64ca14010a69 2024-10-31 17:23:52

文章标签 多线程并发编程 thread java System 文章分类 Java 后端开发

多线程

线程

线程是独立的执行路径
在程序执行时，即使自己没有创建线程，后台也会有多个线程
main（）称为主线程，为系统的入口，用于执行整个程序
在一个进程中如果开辟了多个线程，线程的运行由调度器安排调度，调度器是与操作系统紧密相关的，先后顺序是不能人为干预的
对同一份资源操作时，会存在资源抢夺问题，需要并发控制
线程会带来额外的开销，如cpu的调度时间，并发控制开销
每个线程在自己的工作内存交互，内存控制不当会造成数据不一致

线程创建

继承Thread类

不建议使用：避免oop单继承局限性

主要分为三步： 线程不一定立即执行，等待cpu安排调度

自定义线程类继承Thread类
重写run()方法，编写线程执行体
创建线程对象，调用start()方法启动线程

public class TestThread1 extends Thread{
    @Override
    public void run() {
        //run方法线程体
       for(int i=0;i<100;i++){
           System.out.println("我在看代码----"+i);
       }
    }
    public static void main(String[] args) {
        //主线程
        //创建一个线程对象
        TestThread1 testThread1 = new TestThread1();
        testThread1.start();
        for(int i=0;i<100;i++){
            System.out.println("我在学习多线程----"+i);
        }
    }
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-sK1C1LXD-1602064491112)(C:\Users\Administrator\Pictures\Camera Roll\5.png)]

实现Runnable接口

推荐使用：灵活方便，方便同一个对象呗多个线程使用

自定义线程类实现Runnable接口
重写run()方法，编写线程执行体
创建线程对象，调用start()方法启动线程

public class TestThread2 implements Runnable{
    @Override
    public void run() {
        //run方法线程体
        for(int i=0;i<200;i++){
            System.out.println("我在看代码----"+i);
        }
    }
    public static void main(String[] args) {
        //主线程
        //创建一个线程对象
        TestThread2 testThread2 = new TestThread2();
        new Thread(testThread2).start();
        for(int i=0;i<200;i++){
            System.out.println("我在学习多线程----"+i);
        }
    }
}

实现Callable接口

（了解即可）

实现Callable接口，需要返回值类型
重写call方法，需要抛出异常
创建目标对象
创建执行服务：ExecutorService ser=Executors.newFixedThreadPool(线程数量);
提交执行：Future result1=ser.submit(线程对象);
获取结果：boolean r1=result1.get();
关闭服务：ser.shutdownNow();

好处：可以定义返回值、可以抛出异常

线程停止

不推荐使用JDK提供的stop（）、destroy（）方法
推荐线程自己停下来
建议使用一个标签位进行终止变量，当flag=false，则终止进程运行

public class TestStop implements Runnable {
    private Boolean flag=true;
    @Override
    public void run() {
        int i=0;
        while (flag){
            System.out.println("run...."+i++);
        }
    }
    public void stop(){
        this.flag=false;
    }

    public static void main(String[] args) {
        TestStop testStop = new TestStop();
        new Thread(testStop).start();
        for(int i=0;i<1000;i++){
            System.out.println("main"+i);
            if(i==900){
                testStop.stop();
                System.out.println("停止");
            }
        }
    }
}

线程休眠_sleep

(sleep放大问题的发生性)

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

import java.text.SimpleDateFormat;
import java.util.Date;

public class TestSleep {
    public static void main(String[] args) {
        Date date = new Date(System.currentTimeMillis());
        while (true){
            try {
                Thread.sleep(1000);
                System.out.println(new SimpleDateFormat("HH:mm:ss").format(date));
                date=new Date(System.currentTimeMillis());
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    public static void tenDown() throws InterruptedException {
        int num=10;
        while (true){
            Thread.sleep(1000);
            System.out.println(num--);
            if(num<=0) {
                break;
            }
        }
    }
}

线程礼让_yield

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

public class TestYield {
    public static void main(String[] args) {
        MyYield myYield = new MyYield();
        new Thread(myYield,"A").start();
        new Thread(myYield,"B").start();
    }
}
class MyYield implements Runnable{
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"开始执行");
        Thread.yield();
        System.out.println(Thread.currentThread().getName()+"结束执行");
    }
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-s4TOHEsf-1602064491120)(C:\Users\Administrator\Pictures\Camera Roll\8.png)]

线程强制执行_join

join合并线程，待此线程执行完成后，再执行其他线程，其他此线程阻塞。 可以想象成插队

public class TestJoin implements Runnable{
    public static void main(String[] args) {
        Thread thread = new Thread(new TestJoin());
        thread.start();
        for(int i=0;i<50;i++){
            if(i==20){
                try {
                    thread.join();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println("普通"+i);
        }
    }
    @Override
    public void run() {
        for(int i=0;i<100;i++){
            System.out.println("Vip"+i);
        }
    }
}

观测线程状态

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-RhbOZgi8-1602064491121)(C:\Users\Administrator\Pictures\Camera Roll\7.png)]

一个线程可以在给定时间点处于一个状态，这些状态是不反映任何操作系统线程状态的虚拟机状态

线程状态有以下几种：使用 Thread.state

new：尚未启动的线程处于此状态
runnable：在虚拟机中执行的线程处于此状态
blocked：被阻塞等待监视器锁定的线程处于此状态
waiting：正在等待另一个线程执行特定动作的的线程处于此状态
time_waiting：正在等待另一个线程执行动作达到指定等待时间的线程处于此状态
terminated：已退出的线程处于此状态

public class TestState {
    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(()->{
            for(int i=0;i<5;i++){
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println("/");
        });
        //观察开始状态
        Thread.State state=thread.getState();
        System.out.println(state);
        //观察启动状态
        thread.start();
        state=thread.getState();
        System.out.println(state);
        while (state!=Thread.State.TERMINATED){//只要线程不终止，一直输出状态
            Thread.sleep(1000);
            state=thread.getState();//更新线程状态
            System.out.println(state);
        }
    }
}

线程优先级

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

优先级低只是意味着获得调度的概率低，并不是优先级低就不会被调用了，这还要看cpu的调度

线程的优先级用数字表示，范围从1-10
主线程默认优先级为5
先设置优先级再启动
设置优先级和获取优先级使用setPriority（int xxx）和getPriority（）

public class TestPriority {
    public static void main(String[] args) {
        System.out.println(Thread.currentThread().getName()+"=>"+Thread.currentThread().getPriority());
        MyPriority myPriority = new MyPriority();
        Thread t1 = new Thread(myPriority);
        Thread t2 = new Thread(myPriority);
        Thread t3 = new Thread(myPriority);
        Thread t4= new Thread(myPriority);
        Thread t5 = new Thread(myPriority);
        t1.start();
        t2.setPriority(6);
        t2.start();
        t3.setPriority(10);
        t3.start();
        t4.setPriority(4);
        t4.start();
        t5.setPriority(8);
        t5.start();
    }
}
class MyPriority implements Runnable{
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"=>"+Thread.currentThread().getPriority());
    }
}

守护(daemon)线程

线程分为用户线程和守护线程
虚拟机必须确保用户线程执行完毕，不需要等待守护线程执行完毕
守护线程有操作日志、监控内存、垃圾回收等

public class TestDaemon {
    public static void main(String[] args) {
        new Thread(new Your()).start();
        Thread thread=new Thread(new A());
        thread.setDaemon(true);//默认为false，表示为用户线程，true为守护线程
        thread.start();
    }
}
class A implements Runnable{
    @Override
    public void run() {
       while (true){
           System.out.println("守护你");
       }
    }
}
class Your implements Runnable{
    @Override
    public void run() {
        for(int i=0;i<36500;i++){
            System.out.println("开心");
        }
        System.out.println("拜拜");
    }
}

线程同步

三大不安全案例

使用抢票为例：出现多个线程抢到同一张票和负票的问题

public class BuyTicket implements Runnable {
    private int num=10;
    boolean flag=true;
    @Override
    public  void run() {
        while (flag){
            try {
                buy();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    private synchronized void buy() throws InterruptedException {
        if(num<=0){
            flag=false;
            return;
        }
        Thread.sleep(100);
        System.out.println(Thread.currentThread().getName()+"拿到了第"+num--+"票");
    }
    public static void main(String[] args) {
        TestThread3 testThread3 = new TestThread3();
        new Thread(testThread3,"老师").start();
        new Thread(testThread3,"小明").start();
        new Thread(testThread3,"黄牛").start();
    }
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Cjy7bIAK-1602064491126)(C:\Users\Administrator\Pictures\Camera Roll\6.png)]

银行取钱

如果两个人同时取一张银行卡里的钱就会出现

public class UnSafeBank {
    public static void main(String[] args) {
        Account account=new Account(100,"A");
        Drawing you =new Drawing(account,50,"B");
        Drawing yourFirend=new Drawing(account,100,"C");
        you.start();
        yourFirend.start();
    }
}
//账户
class Account{
    double money;
    String name;

    public Account(double money, String name) {
        this.money = money;
        this.name = name;
    }
}
//银行
class Drawing extends Thread{
    Account account;//账户
    double drawingMoney;//取的钱
    double nowMoney;//现在手里的钱

    @Override
    public void run() {
        if(account.money-drawingMoney<0){
            System.out.println(Thread.currentThread().getName()+"钱不够，取不了");
            return;
        }
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        account.money=account.money-drawingMoney;
        nowMoney=nowMoney+drawingMoney;
        System.out.println(account.name+"余额为："+account.money);
        System.out.println(this.getName()+"手里的钱："+nowMoney);//=Thread.currentThread().getName();
    }
    public Drawing(Account account, double drawingMoney, String name){
        this.account=account;
        this.drawingMoney=drawingMoney;
    }
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-UFpK9dsy-1602064491127)(C:\Users\Administrator\Pictures\Camera Roll\9.png)]

集合问题

使用多个线程同时操作一个集合出现数量不匹配问题

public class UnSafeList {
    public static void main(String[] args) {
        List<String> list=new ArrayList<String>();
        for(int i=0;i<100000;i++){
            new Thread(()->
                list.add(Thread.currentThread().getName())).start();
        }
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(list.size());
    }
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-albPsvzG-1602064491128)(C:\Users\Administrator\Pictures\Camera Roll\10.png)]

同步方法及同步块

由于我们可以通过private关键字来保证数据对象只等被方法访问，我们也能使用synchronized关键字针对方法

同步方法：

public synchronized void method(int args){}

synchronized方法控制对“对象”的访问，每一个对象对应一把锁，每个synchronized方法都必须获得调用改方法的对象的锁才能执行，否则线程会阻塞，方法一旦执行，就独占该锁，直到该方法返回才释放锁，后面被阻塞的线程才能获得这个锁，继续执行

**缺陷：**若将一个大的方法申明为synchronized将会影响效率

方法里面需要修改的内容才需要锁，锁的太多浪费资源
synchronized默认锁的是this

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-uGdsC9nk-1602064491129)(C:\Users\Administrator\Pictures\Camera Roll\11.png)]

同步块：

锁的对象就是变化的量，需要增删改的对象

synchronized(Obj){}

Obj称之为***同步监视器***，可以是任何对象，但是推荐使用共享资源作为同步监视器

同步监视器的执行过程：

第一线程访问，锁定同步监视器，执行其中代码
第二线程访问，发现同步监视器被锁定，无法访问
第一线程访问完毕，解锁同步监视器
第二线程访问，发现同步监视器没有锁，然后锁定并访问

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-cmqoYvDe-1602064491129)(C:\Users\Administrator\Pictures\Camera Roll\12.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Tgvzj40K-1602064491130)(C:\Users\Administrator\Pictures\Camera Roll\13.png)]

list还能使用CopyOnWriteArrayList实现安全集合

public class TestSafeList {
    public static void main(String[] args) {
        CopyOnWriteArrayList<String> list=new CopyOnWriteArrayList<String>();
        for(int i=0;i<100000;i++){
            new Thread(()->{
                list.add(Thread.currentThread().getName());
            }).start();
        }
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(list.size());
    }
}

死锁

多个线程各自占用一些共享资源，并且相互等待其他线程占有的资源才能运行，而导致两个或多个线程都在等待对方释放资源，都停止执行的情形

死锁避免的方法：

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

Lock锁

从JDK5.0开始，java提供了更强大的线程同步机制----通过显式定义同步锁对象来实现同步，同步锁使用Lock对象充当
ReentrantLock类实现了Lock，它拥有synchronized相同的并发性和内存语义，在实现线程安全的控制中，比较常用的是ReentrantLock，可以显式加锁、释放锁

语句：

class A{
    private final ReentrantLock lock=new ReentrantLock();
    public void f(){
        lock.lock();
        try{
            //保证线程安全代码
        }catch(){  
        }finally{
            lock.unlock();
            //如果同步代码有异常，要将unlock（）写入finally语句块
        }  
    }
}

public class TestLock {
    public static void main(String[] args) {
        TestLock2 testLock2 = new TestLock2();
        new Thread(testLock2).start();
        new Thread(testLock2).start();
        new Thread(testLock2).start();
    }
}
class TestLock2 implements Runnable{
    int num=10;
    private final ReentrantLock lock=new ReentrantLock();
    @Override
    public void run() {
        while(true){
            try{
                lock.lock();
                if(num>0){
                    try { 
                        Thread.sleep(1000); 
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(num--);
                }else {
                    break;
                }
            }finally{
                lock.unlock();
            }
        }
    }
}

synchronized和Lock对比

Lock是显式锁（手动开启和关闭锁，别忘了关闭锁），synchronized是隐式锁，出了作用域自动释放
Lock只有代码块锁，synchronized有代码块锁和方法锁
使用Lock锁，JVM将花费较少的时间来调度线程，性能更好，并且具有更好的扩展性（提供更多的子类）
优先使用顺序：Lock>同步代码块>同步方法>

Lambda表达式

为什么使用Lambda表达式：

避免匿名内部类定义过多
可以让代码看起来简洁
去掉一堆没有意义的代码，只留下核心的逻辑

（params）->expression[表达式]

（params）->statement[语句]

（params）->{statements}

例：new Thread(()->System.out.println(“多线程学习…”)).start();

静态代理模式

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

好处：

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

以结婚使用婚庆公司举例

public class staticProxy {
    public static void main(String[] args) {
        new MarryManage(new You()).HappyMarry();
    }
}
//具体实例，结婚的人
class You implements Marry{
    @Override
    public void HappyMarry() {
        System.out.println("结婚很开心");
    }
}
//结婚这件事的接口
interface Marry{
    void HappyMarry();
}
//婚庆公司负责代理结婚事项
class MarryManage implements Marry{
    private Marry target;
    @Override
    public void HappyMarry() {
        before();
        this.target.HappyMarry();
        after();
    }
    public MarryManage(Marry target) {
        this.target = target;
    }
    private void after() {
        System.out.println("结束");
    }
    private void before() {
        System.out.println("开始");
    }
}

多线程静态代理比较

new MarryManage(new You()).HappyMarry();
new Thread(()->System.out.println("***")).start();

线程协作

并发协作模型“生产者/消费者模式”—>管程法

生产者：负责生产数据的模块
消费者：负责处理数据的模块
缓冲区：消费者不能直接使用生产者的数据，他们之间有个缓冲区，生产者将生产好的数据放入缓冲区。消费者从缓冲区拿出数据

管程法

生产者消费者模式

public class TestPC1 {
    public static void main(String[] args) {
        SynContainer container=new SynContainer();
        new Productor(container).start();
        new Consumer(container).start();
    }
}
//生产者
class Productor extends Thread{
    SynContainer container;
    public Productor(SynContainer container){
        this.container=container;
    }
    @Override
    public void run() {
        for(int i=0;i<100;i++){
            container.push(new Chicken(i));
            System.out.println("生产了"+i+"只鸡");
        }
    }
}
//消费者
class Consumer extends Thread{
    SynContainer container;
    public Consumer(SynContainer container){
        this.container=container;
    }
    @Override
    public void run() {
        for(int i=0;i<100;i++){
            System.out.println("消费者消费了"+container.pop().id+"只鸡");
        }
    }
}
//产品
class Chicken{
    int id;
    public Chicken(int id) {
        this.id = id;
    }
}
//缓冲区
class SynContainer{
    Chicken[] chickens=new Chicken[10];
    int count=0;//计数器
    //生产者放入产品
    public synchronized void push(Chicken chicken){
        if(count==chickens.length){//如果容器满了，就需要等待消费者消费
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        chickens[count]=chicken;
        count++;
        this.notifyAll();//通知消费者消费
    }
    //消费者消费产品
    public synchronized Chicken pop(){
        if(count==0){//判断能否消费
            try {
                this.wait();//等待生产者生产
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        count--;
        Chicken chicken=chickens[count];
        this.notifyAll();//吃完了通知生产者生产
        return chicken;
    }
}

信号灯法

public class TestPC2 {
    public static void main(String[] args) {
        TV tv=new TV();
        new Player(tv).start();
        new Watcher(tv).start();
    }
}
class Player extends Thread{
    TV tv;
    public Player(TV tv){
        this.tv=tv;
    }
    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            if(i%2==0){
                this.tv.play("快乐大本营");
            }else{
                this.tv.play("抖音");
            }
        }
    }
}
class Watcher extends Thread{
    TV tv;
    public Watcher(TV tv){
        this.tv=tv;
    }

    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            tv.watch();
        }
    }
}
class TV{
    //演员表演，观众等待
    //观众表演，演员等待
    String voice;
    boolean flag=true;
    //表演
    public synchronized void play(String voice){
        if(!flag){
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println("演员表演了"+voice);
        this.notifyAll();//通知观众观看
        this.voice=voice;
        this.flag=!this.flag;
    }
    //观看
    public synchronized void watch(){
        if(flag){
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println("观看了"+voice);
        this.notifyAll();//通知演员表演
        this.flag=!this.flag;
    }
}

线程池

提前创建好多个线程，放入线程池中，使用时直接获取，使用完放回池中。

好处：

提高响应速度（减少了创建线程的时间）
降低资源消耗（重复利用线程池中线程，不需要每次都创建）
便于线程管理

ExecutorService:真正的线程池接口。常见子类ThreadPoolExecutor

1. void execute(Runnable command):执行任务、命令，没有返回值，一般用来执行Runnable

2. <T>Future<T>submit(Callable<T> task):执行任务，有返回值，一般用来执行Callable
3. void shutdown():关闭连接池

Executors：工具类、线程池的工厂类，用于创建并返回不同类型的线程池

public class TestPool {
    public static void main(String[] args) {
        ExecutorService executorService = Executors.newFixedThreadPool(10);
        executorService.execute(new MyThread());
        executorService.execute(new MyThread());
        executorService.execute(new MyThread());
        executorService.execute(new MyThread());
        executorService.shutdown();
    }
}
class MyThread implements Runnable{
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName());
    }
}

本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。