专项攻克——线程

已于 2023-03-15 11:29:49 修改
阅读量167 收藏
点赞数
分类专栏： 高并发编程 文章标签： java 开发语言
于 2022-11-08 15:30:38 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_18683559/article/details/127751667
版权

文章目录

一、线程创建方式

1.1 常见的四种线程创建方式、使用案例

参考博客线程创建常用的四种方式

  1. 继承Thread类创建线程
  2. 实现Runnable接口创建线程【推荐】 场景：临时使用，内部方法，不被外部对象使用
  3. 使用Callable和Future创建线程
  4. 使用线程池例如用Executor框架
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.FutureTask;

public class ThreadTest_2 {
    //继承Thread
    public static class MyThread extends Thread {
        @Override
        public void run () {
            System.out.println("1 继承Thread类 方式");
        }
    }

    //实现Runnable
    public static class MyRunnable implements Runnable {
        @Override
        public void run () {
            System.out.println("2.1 实现Runnable接口 方式");
            System.out.println("2.1 " + Thread.currentThread().getName());
        }
    }

    //实现Callable接口
    public static class MyCallable implements Callable {
        @Override
        public Integer call() throws Exception {
            System.out.println("3 实现Callable接口 方式");
            System.out.println("3 " + Thread.currentThread().getName());
            return 200;
        }
    }

    public static void main(String[] args) {
        //1.继承Thread类
        new MyThread().start();

        //2.1 实现Runnable接口（完整版）
        MyRunnable myRunnable = new MyRunnable();
        Thread thread = new Thread(myRunnable);
        thread.start();

        //2.2 实现Runnable接口（缩写版）
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("2.2 实现Runnable接口 方式");
            }
        }).start();

        //3.1 实现Callable接口（完整版）
        FutureTask<Integer> futureTask = new FutureTask<Integer>(new MyCallable());
        Thread threadFuture = new Thread(futureTask, "threadFuture完整版");
        threadFuture.start();
        try {
            System.out.println(futureTask.get());//get()方法会阻塞，直到子线程执行结束才返回
        } catch (Exception e){
            System.out.println(e);
        }

        //3.2 实现Callable接口（缩写版）
        new Thread(new FutureTask<Integer>(new MyCallable()), "threadFuture缩写版").start();

        // ###############  线程池  ############### 
        //4.1 线程池方式——固定线程数
        ExecutorService executorService1 = Executors.newFixedThreadPool(5);
        executorService1.submit(myRunnable);

        //4.2 线程池方式——单1线程
        ExecutorService executorService2 = Executors.newSingleThreadExecutor();
        executorService2.submit(myRunnable);

        //4.3 线程池方式——缓存短期线程
        ExecutorService executorService3 = Executors.newCachedThreadPool();
        executorService3.submit(myRunnable);

        //4.4 线程池方式——调度型线程
        ExecutorService executorService4 = Executors.newScheduledThreadPool(5);
        executorService4.submit(myRunnable);

        //4.4 线程池方式——多任务队列线程
        ExecutorService executorService5 = Executors.newWorkStealingPool(5);
        executorService5.submit(myRunnable);
    }
}

输出结果
在这里插入图片描述

1.2 区别总结

差别：

  1. Callable规定（重写）的方法是call()，call()可抛出异常，任务执行后可返回值；Runnable规定（重写）的方法是run()，run()不能抛出异常，任务不能返回值。
  2. 运行Callable任务可以拿到一个Future对象，表示异步计算的结果。它提供了检查计算是否完成的方法，以等待计算的完成，并检索计算的结果。通过Future对象可以了解任务执行情况，可取消任务的执行，还可获取执行结果；
  3. 继承Thread类：线程类无法再继承其他父类（Java单继承性质）。
  4. 前三种的线程如果创建关闭频繁会消耗系统资源影响性能；而使用线程池可以重复使用线程

二、Thread和Runnable源码

可以注意到：

  • Runnable 和 Thread 都使用了注解@FunctionalInterface，该注解提示编译器去检查接口是否仅包含一个抽象方法，即，是否符合函数式编程的定义。

2.1 源码——Runnable接口

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

2.2 源码——Thread类

public class Thread implements Runnable {
    ...

    private volatile String name;
    private int            priority;
    private Thread         threadQ;
    private long           eetop;
    private boolean     single_step;
    private boolean     daemon = false;
    private boolean     stillborn = false;
    private Runnable target;
    private ThreadGroup group;
    private ClassLoader contextClassLoader;
    private AccessControlContext inheritedAccessControlContext;
    private static int threadInitNumber;
    private static synchronized int nextThreadNum() {
        return threadInitNumber++;
    }

    /* 重要！ */
    ThreadLocal.ThreadLocalMap threadLocals = null;

    /*
     * 重要！ This map is maintained by the InheritableThreadLocal class.*/
    ThreadLocal.ThreadLocalMap inheritableThreadLocals = null;

    
    private long stackSize;
    private long nativeParkEventPointer;

    /* Thread ID */
    private long tid;
    /* For generating thread ID */
    private static long threadSeqNumber;
    private volatile int threadStatus = 0;
    
    private static synchronized long nextThreadID() {
        return ++threadSeqNumber;
    }

    volatile Object parkBlocker;

    private volatile Interruptible blocker;
    private final Object blockerLock = new Object();

    void blockedOn(Interruptible b) {
        synchronized (blockerLock) {
            blocker = b;
        }
    }

    /** 最低优先级 */
    public final static int MIN_PRIORITY = 1;

   /** 默认优先级 */
    public final static int NORM_PRIORITY = 5;

    /** 最大优先级 */
    public final static int MAX_PRIORITY = 10;

    public static native Thread currentThread();
    
	public static native void yield();
	public static native void sleep(long millis) throws InterruptedException;
	
	public static void sleep(long millis, int nanos) throws InterruptedException {
        if (millis < 0) {
            throw new IllegalArgumentException("timeout value is negative");
        }

        if (nanos < 0 || nanos > 999999) {
            throw new IllegalArgumentException("nanosecond timeout value out of range");
        }

        if (nanos >= 500000 || (nanos != 0 && millis == 0)) {
            millis++;
        }

        sleep(millis);
    }
    
    private void init(ThreadGroup g, Runnable target, String name, long stackSize) {
        init(g, target, name, stackSize, null, true);
    }

	private void init(ThreadGroup g, Runnable target, String name,
                      long stackSize, AccessControlContext acc,
                      boolean inheritThreadLocals) {
        if (name == null) {
            throw new NullPointerException("name cannot be null");
        }

        this.name = name;

        Thread parent = currentThread();
        SecurityManager security = System.getSecurityManager();
        if (g == null) {
            if (security != null) {
                g = security.getThreadGroup();
            }
            if (g == null) {
                g = parent.getThreadGroup();
            }
        }
        
        g.checkAccess();

        if (security != null) {
            if (isCCLOverridden(getClass())) {
                security.checkPermission(SUBCLASS_IMPLEMENTATION_PERMISSION);
            }
        }

        g.addUnstarted();

        this.group = g;
        this.daemon = parent.isDaemon();
        this.priority = parent.getPriority();
        if (security == null || isCCLOverridden(parent.getClass()))
            this.contextClassLoader = parent.getContextClassLoader();
        else
            this.contextClassLoader = parent.contextClassLoader;
        this.inheritedAccessControlContext =
                acc != null ? acc : AccessController.getContext();
        this.target = target;
        setPriority(priority);
        if (inheritThreadLocals && parent.inheritableThreadLocals != null)
            this.inheritableThreadLocals =
                ThreadLocal.createInheritedMap(parent.inheritableThreadLocals);
        /* Stash the specified stack size in case the VM cares */
        this.stackSize = stackSize;

        /* Set thread ID */
        tid = nextThreadID();
    }

	...

	public synchronized void start() {
        if (threadStatus != 0)
            throw new IllegalThreadStateException();

        group.add(this);

        boolean started = false;
        try {
            start0();
            started = true;
        } finally {
            try {
                if (!started) {
                    group.threadStartFailed(this);
                }
            } catch (Throwable ignore) {
            }
        }
    }
    
    @Override
    public void run() {
        if (target != null) {
            target.run();
        }
    }
	
	...
	

}

三、等待多个线程执行完

背景：最近做了一个需求，要求返回某个企业所有“品牌入驻”任务的完成情况，这些入驻完成情况需要调用其他服务器的接口服务来检测，有如下两种做法：

  1. 直接顺序执行：在一条线程里挨个检测“所有入驻任务”完成情况，此时接口服务调用是按照顺序执行的。
    【缺点：任务较多时，执行时间会增大。】
  2. 多线程：让每个线程去检测“入驻任务”完成情况，而主线程等待所有任务完成后再组合返回。
    【疑问：怎么让某个线程等待它开启的所有线程执行完后再执行呢？】

3.1 CountDownLatch 计数法

原因：

  • countDownLatch.await()会阻塞当前线程，直到countDownLatch的值等于0
  • countDownLatch不可能重新初始化或者修改CountDownLatch对象内部计数器的值，一个线程调用countdown方法happen-before另外一个线程调用await方法
import java.util.concurrent.CountDownLatch;

public class CountDownLatchTest_3 {
    public static void main(String[] args) {
        int total = 5;
        final CountDownLatch countDownLatch = new CountDownLatch(total);
        for (int i = 0; i < total; i++) {
            new Thread(new Runnable(){
                @Override
                public void run(){
                    System.out.println(Thread.currentThread().getName() + 
                    	"，countDownLatch当前值" + countDownLatch.getCount());
                    countDownLatch.countDown();
                }
            }).start();
        }

        try {
            countDownLatch.await();
            System.out.println("全部线程执行完成");
        } catch (InterruptedException e) {
            System.out.println(e);
        }
    }
}

结果输出
在这里插入图片描述

3.2 CyclicBarrier 同步屏障

  • cyclicBarrier.await()会阻塞当前线程，直到cyclicBarrier的值等于0 即所有线程都到到了await状态，才会继续执行。
  • 有两种需求，一种是不需要汇总，一种需要汇总。如下。

3.2.1 到达屏障不汇总

  • 当最后一个线程到达时，不进行汇总，屏障直接消除，所有线程继续执行。
    在这里插入图片描述
  • 案例：
import java.util.concurrent.CyclicBarrier;

public class CyclicBarrierTest_4 {
    public static void main(String[] args) {
        int total = 5;
        final CyclicBarrier cyclicBarrier = new CyclicBarrier(total);
        for (int i = 0; i < total; i++) {
            new Thread(new Runnable(){
                @Override
                public void run(){
                    try {
                        System.out.println(Thread.currentThread().getName() + "前");
                        cyclicBarrier.await();//到达屏障
                        System.out.println("全部线程都到达了屏障");
                        System.out.println(Thread.currentThread().getName() + "后");
                    } catch (Exception e) {
                        System.out.println(e);
                    }
                }
            }).start();
        }

        try {
            System.out.println(Thread.currentThread().getName() + "，cyclicBarrier当前值" + cyclicBarrier.getNumberWaiting());
        } catch (Exception e) {
            System.out.println(e);
        }
    }
}

输出结果：
在这里插入图片描述

3.2.2 到达屏障进行汇总

  • 当所有线程到达屏障时，先释放主线程，再进行汇总操作，汇总完后，屏障直接消除，所有线程继续执行
  • 案例：
import java.util.concurrent.CyclicBarrier;

public class CyclicBarrierTest_4 {
    public static void main(String[] args) {
        int total = 5;
        final CyclicBarrier cyclicBarrier = new CyclicBarrier(total, new Runnable() {
            @Override
            public void run(){
                System.out.println(Thread.currentThread().getName() + "，全部线程都到达了屏障");
            }
        });

        for (int i = 0; i < total; i++) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    try {
                        System.out.println(Thread.currentThread().getName() + "前");
                        cyclicBarrier.await();//到达屏障
                        System.out.println(Thread.currentThread().getName() + "后");
                    } catch (Exception e) {
                        System.out.println(e);
                    }
                }
            }).start();
        }

        try {
            System.out.println(Thread.currentThread().getName() + 
            	"，cyclicBarrier当前值" + cyclicBarrier.getNumberWaiting());
        } catch (Exception e) {
            System.out.println(e);
        }
    }
}

输出结果
在这里插入图片描述

四、怎么知道设置多少线程合适？

  • 通常，使用固定线程池限制最大线程数。

  • 在并发编程领域，提升性能的本质，就是提升硬件的利用率： （1）CPU利用率、（2）I/O利用率。

  • 线程数设置多少合适？如下：

    1. 对于CPU密集型场景：如圆周率计算、视频高清解码等，全靠CPU运算能力这种计算密级型任务越多，消耗在任务切换的时间就越多。
      (1). 理论上最合适的是，线程数量=CPU核数。
      (2). 但是在工程上通常设置，线程数量=CPU核数+1。

      原因：当线程偶尔发生内存页失效或其他现象导致阻塞时，这个额外的线程可以顶上，从而保证CPU的利用率。==

    2. 对于 I/O 密集型场景：如网络IO、硬盘IO、Web应用等，这类任务消耗CPU小，大部分时间都在等待IO操作完成。任务越多，CPU效率越高。
      单核最佳线程数=1+(I/O耗时/CPU耗时)，针对多核CPU，目前见过两种比较合理的公式：
      (1). 多核最佳线程数=CPU核数×100%×[1+(I/O耗时/CPU耗时)]
      (2). 多核最佳线程数=CPU核数×目标CPU利用率×(1+平均等待时间/平均工作时间)

      案例：假设有n个任务，每个任务I/O耗时10s，每个任务CPU耗时1s。如果CPU的核数是4核，则最佳线程数=4x(1+10/1)=44。
      可以理解为，在一个核上，10个任务同时执行的耗时与一个任务的执行耗时是相同的，都是10s。

CPU与I/O理解案例：假设程序按照CPU计算和I/O操作交叉执行的方式运行，而且CPU计算和I/O操作的耗时比例是1:1。

  1. 如下图，如果只有一个线程，执行CPU计算时，I/O设备空闲；执行I/O操作时，CPU空闲。所以CPU的利用率和I/O设备的利用率都是50%
    在这里插入图片描述
  2. 如果有两个线程，如下图所示，当线程A执行CPU计算的时候，线程B执行I/O操作；当线程A执行I/O操作的时候，线程B执行CPU计算，这样CPU的利用率和I/O设备的利用率就都达到了100%
    在这里插入图片描述
攻城有术
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
攻克学习多线程时碰到的难题
10-25
在学习多线程的过程中，经常会...总结来说，理解并掌握线程的创建、同步以及线程间的通信和协作是攻克多线程学习难题的关键。不断实践和探索，将有助于你在实际项目中灵活运用多线程技术，提高程序的效率和并发能力。
攻克多线程时碰到的难题
06-14
得的是对象锁，即一次只有一个线程能访问该对象中的synchronized代码块。这确保了在多线程环境中，同一时间只有一个线程可以执行特定对象的相关操作。 ```java public class MyClass { private Object obj = new ...
专项攻克——事务
最新发布
军威兄的博客
03-31 858
事务、分布式事务攻克
专项攻克——死锁
军威兄的博客
03-15 1005
死锁定义：是指多个线程因竞争资源而造成的一种僵局（互相等待），若无外力作用，这些进程都将无法向前推进。
专项攻克——垃圾回收机制
军威兄的博客
03-21 436
专项攻克——垃圾回收机制
专项攻克——线程池
军威兄的博客
09-03 6203
文章目录五种线程池的使用场景线程池的继承关系线程池的具体实现类ThreadPoolExecutor的重要参数==线程池的几步主要工作流程思路分析==线程池都有哪几种工作队列 多线程面试问题 参考博客 五种线程池的使用场景 一个使用线程池管理线程的例子：//创建一个可重用固定线程数量的线程池 ExecutorService pool = Executors.newFixedThreadPool...
专项攻克——redis
军威兄的博客
09-03 396
redis数据类型、redis问题
专项攻克汇总——问题与解答
军威兄的博客
03-20 332
文章目录一、Java基础二、数据库三、Redis四、Spring、Mybatis五、微服务——zookeeper、JSF六、事务七、分布式job、分布式锁八、算法篇 一、Java基础 类加载机制 jvm内存模型、 jvm内存优化 垃圾回收：gc java集合：hashMap、线程安全 异常与错误 多线程 线程安全：Lock、reentrantLock、synchronized、volatile、CAS 锁：乐观锁、悲观锁 反射机制 自定义注解 二、数据库 三、Redis 四、Spring、Mybatis
专项攻克——BIO、NIO、AIO
军威兄的博客
08-23 159
网络io：AIO、NIO、BIO
专项攻克——MySQL语句与底层原理剖析
军威兄的博客
06-21 634
专项攻克——sql语句与底层支持
OCS——史上最疯狂的iOS动态化方案
Kiven's Program Space
09-09 1425
OCS——史上最疯狂的iOS动态化方案 导语 在iOS的发展历程上，涌现了很多动态化方案，有历史悠久的WaxPatch动态化方案，有远近闻名的JSPatch动态化方案。今天精神哥向大家介绍一款堪称“史上最疯狂”的iOS动态化方案——OCS。 本文来自腾讯 SNG - OCS团队 初窥OCS OCS是全新设计的iOS动态化方案。我们定义了一套精确描述OC语义的字节码指令
网络ARP病毒DIY攻克宝典.docx
10-25
网络ARP病毒DIY攻克宝典
利用仿真攻克汽车系统设计挑战
01-20
当今汽车行业所面临的挑战与电信行业十多年前所经历的类似。混合动力电动汽车和燃料电池汽车等新技术也促进了研发活动的日趋活跃，正如我们在手机演变成多媒体设备的进程中所看到的一样。同样，电信业面临着功耗和...
Tomcat——请求处理、线程池的理解
军威兄的博客
11-10 806
文章目录（一）![在这里插入图片描述](https://img-blog.csdnimg.cn/20191110172123983.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzE4NjgzNTU5,size_16,color_F...
java线程、锁、CAS、AQS、CountDownLatch
军威兄的博客
08-26 627
参考简书 锁的本质就是线程等待，可以分为线程阻塞和线程自旋，关于他们的区别： 阻塞：要阻塞或唤醒一个线程就需要操作系统介入，需要在户态与核心态之间切换，这种切换会消耗大量的系统资源。 如果线程状态切换是一个高频操作时，这将会消耗很多CPU处理时间， 如果对于那些需要同步的简单的代码块，获取锁挂起操作消耗的时间比用户代码执行的时间还要长，这种同步策略显然非常糟糕的。 自旋：如果持有锁的线程能在很短时...
Lock锁
军威兄的博客
08-26 474
文章目录Lock 锁4.1 Lock 和 synchronized 的不同点4.2 主要的实现类公平锁加锁过程 Lock 锁 4.1 Lock 和 synchronized 的不同点 Lock是一个接口，而 synchronized 是 Java 中的关键字, synchronized是内置的语言实现（虚拟机级）， lock是通过代码实现的.（API级） synchronized 在发生异常时，会...
服务器架构学习——MQ学习总结
军威兄的博客
07-22 383
文章目录一、学习资料 一、学习资料 1、MQ（消息队列）功能介绍 2、消息队列之 RabbitMQ(重点推荐) 二、
多线程使用、synchronized修饰符、源码分析
军威兄的博客
08-01 334
文章目录1. 线程的生命周期1.1 新建1.2 执行start()后，进入队列等待获取CPU时间片1.3 开始运行run()方法1.4 中断1.5 死亡1.6 注意事项： 1. 线程的生命周期 生命周期可参见CSDN博客：https://www.cnblogs.com/fysola/p/6066290.html 1.1 新建 在内存中开启一片资源存储该线程对象 1.2 执行start()后，进入...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

攻城有术

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值