多线程的基本使用

大脸猫-

已于 2023-03-10 15:41:50 修改

阅读量123

点赞数

文章标签： java

于 2023-03-10 15:40:02 首次发布

本文链接：https://blog.csdn.net/qq_36937152/article/details/129443971

版权

Thread

创建和使用线程

Thread

通过Thread类使用多线程。继承Thread类，实现run()方法，再通过start()方法启动。

package study.thread;

/**
 * 多线程MyThread测试类，t1，t2随机按顺序运行
 */
public class ThreadTest extends Thread{

    public static void main(String[] args){
        MyThread t1 = new MyThread("liuyafeng");
        t1.start();
        MyThread t2 = new MyThread("liyazhou");
        t2.start();
    }
}

class MyThread extends Thread{
    private String name;

    public MyThread(){
    }
    public MyThread(String name){
        this.name = name;
    }
    @Override
    public void run() {
        System.out.println(321+name);
    }
}

Runnable

通过Runnable使用多线程。实现Runnable接口，实现run()方法。与Thread不同的是，Runnable是一个接口，不影响类去继承其他类。

package study.thread;

/**
 * 多线程Runnable测试类，t1，t2随机按顺序运行
 */

public class RunnableTest {
    public static void main(String[] args){
        MyRunnable t1 = new MyRunnable("liuyafeng");
        Thread thread = new Thread(t1);
        thread.start();

        MyRunnable t2 = new MyRunnable("liyazhou");
        Thread thread2 = new Thread(t2);
        thread2.start();
    }
}


class MyRunnable implements Runnable{

    private String name;

    public MyRunnable(){
    };

    public MyRunnable(String name){
        this.name=name;
    };

    @Override
    public void run() {
        System.out.println(321+name);
    }
}

Callable

通过Callable使用多线程。实现Callable接口，重写的是**call()**方法。与Thread和Runnable不同的是，Callable支持返回值。使用Callable 需要有 FutureTask的支持，通过FutureTask获取线程执行的结果。

package study.thread;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;

import java.util.concurrent.FutureTask;

/**
 * 多线程MyCallable测试类，创建类事先Callable接口，覆盖call方法
 */
public class CallableTest {
    public static void main(String[] args) throws Exception {
        FutureTask<Integer> a = new FutureTask<>(new MyCallable());
        new Thread(a).start();
        Integer integer = a.get();
        System.out.println(integer);

    }
}

class MyCallable implements Callable<Integer>{

    @Override
    public Integer call() throws Exception {
        int i=0;
        for(int j=0;j<=10000;j++){
            i=i+j;
            System.out.println(j);
        }
        return i;
    }
}

线程之间的调度关系

CountDownLatch

CountDownLatch：闭锁，使一个或一组线程在其他线程执行完毕之前，一直处于等待状态，直到其他线程执行完成后再继续执行。

eg：高考，所有人都交卷离场了，老师才能离场。

CyclicBarrier

CyclicBarrier：循环栅栏，通过 CyclicBarrier 可以实现一组线程之间的相互等待，当所有线程都到达屏障点之后再执行后续的操作。通过 await() 方法可以实现等待，当最后一个线程执行完，会使得所有在相应 CyclicBarrier 实例上的等待的线程被唤醒，而最后一个线程自身不会被暂停。

eg：高考，有的人答题速度快，有的人答题速度慢，但不允许提前交卷，大家都在等铃声响起，一起交卷。

Semaphore

Semaphore：是用来控制同时访问特定资源的线程数量，通过协调各个线程以保证合理地使用公共资源。

eg:一个游戏服务器只允许200个账号登录，除非有人下线，否则第201个用户无法登录。

线程池

线程池类图结构：

在这里插入图片描述

其中：

Executor:运行新任务的简单接口
ExecutorService：扩展了Executor，添加了用来管理执行器生命周期和任务生命周期的方法
ScheduleExcutorService：扩展了ExecutorService，支持Future和定期执行任务
ForkJoinPool：分叉(fork)合并(join)，将一个大任务拆分成多个小任务，并行执行，再结合工作窃取模式(worksteal)提高整体的执行效率，充分利用CPU资源。与 ThreadPoolExecutor 不同的是，每个线程都单独维护一个队列。

ThreadPoolExecutor

参数说明：ThreadPoolExecutor一共有七个参数，这七个参数配合起来，构成了线程池强大的功能。

corePoolSize：核心线程数量
maximumPoolSize：线程最大线程数
workQueue：阻塞队列，存储等待执行的任务，很重要，会对线程池运行过程产生重大影响

当我们提交一个新的任务到线程池，线程池会根据当前池中正在运行的线程数量来决定该任务的处理方式。处理方式有三种：
1、直接切换（SynchronusQueue）

2、有界队列（ArrayBlockingQueue）最大maximumPoolSize，能够降低资源消耗，但是这种方式使得线程池对线程调度变的更困难。因为线程池与队列容量都是有限的。所以想让线程池的吞吐率和处理任务达到一个合理的范围，又想使我们的线程调度相对简单，并且还尽可能降低资源的消耗，我们就需要合理的限制这两个数量。

3、无界队列（LinkedBlockingQueue）能够创建的最大线程数为corePoolSize,这时maximumPoolSize就不会起作用了。当线程池中所有的核心线程都是运行状态的时候，新的任务提交就会放入等待队列中。

4、分配技巧： [如果想降低资源的消耗包括降低cpu使用率、操作系统资源的消耗、上下文切换的开销等等，可以设置一个较大的队列容量和较小的线程池容量，这样会降低线程池的吞吐量。如果我们提交的任务经常发生阻塞，我们可以调整maximumPoolSize。如果我们的队列容量较小，我们需要把线程池大小设置的大一些，这样cpu的使用率相对来说会高一些。但是如果线程池的容量设置的过大，提高任务的数量过多的时候，并发量会增加，那么线程之间的调度就是一个需要考虑的问题。这样反而可能会降低处理任务的吞吐量。
keepAliveTime：线程没有任务执行时最多保持多久时间终止（当线程中的线程数量大于corePoolSize的时候，如果这时没有新的任务提交核心线程外的线程不会立即销毁，而是等待，直到超过keepAliveTime
unit：keepAliveTime的时间单位
threadFactory：线程工厂，用来创建线程，有一个默认的工场来创建线程，这样新创建出来的线程有相同的优先级，是非守护线程、设置好了名称）
rejectHandler：当拒绝处理任务时(阻塞队列满)的策略（AbortPolicy默认策略直接抛出异常、CallerRunsPolicy用调用者所在的线程执行任务、DiscardOldestPolicy丢弃队列中最靠前的任务并执行当前任务、DiscardPolicy直接丢弃当前任务）

corePoolSize、maximumPoolSize、workQueue 三者关系：如果运行的线程数小于corePoolSize的时候，直接创建新线程来处理任务。即使线程池中的其他线程是空闲的。如果运行中的线程数大于corePoolSize且小于maximumPoolSize时，那么只有当workQueue满的时候才创建新的线程去处理任务。如果corePoolSize与maximumPoolSize是相同的，那么创建的线程池大小是固定的。这时有新任务提交，当workQueue未满时，就把请求放入workQueue中。等待空线程从workQueue取出任务。如果workQueue此时也满了，那么就使用另外的拒绝策略参数去执行拒绝策略。

package study.thread;

import java.util.concurrent.*;

/**
 * 线程池ThreadPoolExecutor测试类
 */
public class ExecutorServiceTest {
    public static void main(String[] args){
        // 直接切换队列：使用SynchronousQueue队列，提交的任务不会被保存，总是会马上提交执行。如果用于执行任务的线程数量
        // 小于maximumPoolSize，则尝试创建新的进程，如果达到maximumPoolSize设置的最大值，则根据你设置的handler执行
        // 拒绝策略。因此这种方式你提交的任务不会被缓存起来，而是会被马上执行，在这种情况下，你需要对你程序的并发量有个准
        // 确的评估，才能设置合适的maximumPoolSize数量，否则很容易就会执行拒绝策略；
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(2,3,
                30, TimeUnit.MILLISECONDS,new SynchronousQueue<Runnable>(),
                Executors.defaultThreadFactory(),new ThreadPoolExecutor.AbortPolicy());
        //当线程池execute的任务的数量小于最大线程数的时候任务可以正常执行，大于的时候多出的任务会抛出拒绝执行异常
        for(int i=0;i<4;i++) {
            threadPoolExecutor.execute(new ThreadTask());
        }
        // 有界队列：使用ArrayBlockingQueue有界任务队列，若有新的任务需要执行时，线程池会创建新的线程，直到创建的线程数
        // 量达到corePoolSize时，则会将新的任务加入到等待队列中。若等待队列已满，即超过ArrayBlockingQueue初始化的容
        // 量，则继续创建线程，直到线程数量达到maximumPoolSize设置的最大线程数量，若大于maximumPoolSize，则执行拒绝
        // 策略。在这种情况下，线程数量的上限与有界任务队列的状态有直接关系，如果有界队列初始容量较大或者没有达到超负荷的
        // 状态，线程数将一直维持在corePoolSize以下，反之当任务队列已满时，则会以maximumPoolSize为最大线程数上限。
        ThreadPoolExecutor array = new ThreadPoolExecutor(1, 2, 1000, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),Executors.defaultThreadFactory(),new ThreadPoolExecutor.AbortPolicy());
        // 无界队列：使用无界任务队列，线程池的任务队列可以无限制的添加新的任务，而线程池创建的最大线程数量就是你corePoolSize
        // 设置的数量，也就是说在这种情况下maximumPoolSize这个参数是无效的，哪怕你的任务队列中缓存了很多未执行的任务，
        // 当线程池的线程数达到corePoolSize后，就不会再增加了；若后续有新的任务加入，则直接进入队列等待，当使用这种任
        // 务队列模式时，一定要注意你任务提交与处理之间的协调与控制，不然会出现队列中的任务由于无法及时处理导致一直增长，
        // 直到最后资源耗尽的问题。
        ThreadPoolExecutor linked = new ThreadPoolExecutor(1, 2, 1000, TimeUnit.MILLISECONDS, new LinkedBlockingQueue<Runnable>(),Executors.defaultThreadFactory(),new ThreadPoolExecutor.AbortPolicy());

    }
}

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

ForkJoin

与 ThreadPoolExecutor不同的是，ForkJoinPool 的每个线程都有自己的队列，适用于计算密集型的场景。通过类实现ForkJoinTask（或继承他的子类、实现子接口）的compute()方法，实现逻辑，同过invokeAll()方法实现调用。

package study.thread;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.RecursiveAction;

/**
 * ForkJoin测试类
 */
public class ForkJoinTest {
    public static void main(String[] args){
        ForkJoinPool forkJoinPool = new ForkJoinPool();
        List<Integer> list = new ArrayList<>();
        for(int i=1;i<=1000;i++){
            list.add(i);
        }
        MyTask myTask = new MyTask(list, list.size());
        forkJoinPool.invoke(myTask);
        int poolSize = forkJoinPool.getPoolSize();
        int activeThreadCount = forkJoinPool.getActiveThreadCount();
        long stealCount = forkJoinPool.getStealCount();
        System.out.println("线程池线程数["+poolSize+"],活跃线程数["+activeThreadCount+"],窃取任务数["+stealCount+"]");
    }
}

class MyTask extends RecursiveAction {

    private List<Integer> list;
    private int count;

    public MyTask() {
    }

    public MyTask(List<Integer> list,int count) {
        this.list = list;
        this.count = count;
    }

    @Override
    protected void compute() {
        //当任务颗粒度大于既定阈值的时候，继续分割任务
        if(count>200){
            int middle = count/2;
            MyTask myTask1 = new MyTask(list.subList(0,middle),middle);
            MyTask myTask2 = new MyTask(list.subList(middle,count),middle);
            invokeAll(myTask1,myTask2);
        }else{
            //执行逻辑
            for(Integer a:list){
                System.out.println(a);
            }
        }
    }
}

invokeAll和submit的区别：

submit提交任务后，直接返回一个Future对象，不会立即返回结果，当不需要等待任务结果时，可使用submit。

invokeAll提交任务后，当所有任务执行完成返回。当需要等待任务结果时，使用invokeAll。

CompletableFuture

CompletionStage的接口一般都返回新的CompletionStage，表示执行完一些逻辑后，生成新的CompletionStage，构成链式的阶段型的操作。其中参数：

函数式编程的常用参数类：

Function 有返回值的函数，使用accept函数

Consumer 必须有参数的函数，使用apply函数

Supplier 有返回值的函数，使用get函数

代码示例：

package study.thread;

import java.util.concurrent.CompletableFuture;

/**
 * CompletableFuture测试类
 */
public class CompletableFutureTest {
    public static void main(String[] args) throws Exception{

        //执行一个异步任务，没有返回值
        CompletableFuture a = CompletableFuture.runAsync(() ->
                System.out.println(1));

        //执行一个异步任务，有返回值
        CompletableFuture<String> b = CompletableFuture.supplyAsync(() ->{
                System.out.println(2);
        return "2a";
        });
        String s = b.get();
        System.out.println(s);

        //任务d在任务c之后完成
        CompletableFuture c = CompletableFuture.runAsync(() ->
                System.out.println("c")).thenRun(()->{
            System.out.println("d");
        });

        //任务f在任务e之后完成并且拿到e的返回值
        CompletableFuture.supplyAsync(() ->{
                    System.out.println("e");
                    return"e";
                }).thenAccept(ereturn->{
            System.out.println(ereturn+"f");
        });

        //任务f在任务e之后完成并且拿到e的返回值,并且返回自己
        CompletableFuture<String> g = CompletableFuture.supplyAsync(() ->{
            System.out.println("g");
            return"g";
        }).thenApply(greturn->{
            return greturn+"h";
        });
        String s1 = g.get();
        System.out.println(s1);

    }
}

线程安全问题

通过以下代码展示线程安全问题：

package study.thread;

/**
 * 线程安全测试类：模拟多线程并发带来的问题
 */
public class ThreadSafeTest {
    public static void main(String[] args) throws InterruptedException {

        MyList list = new MyList();
        Thread thread1 = new Thread(() -> {
            list.add("c");
        });

        Thread thread2 = new Thread(() -> {
            list.add("d");
        });
        //启动线程
        thread1.start();
        thread2.start();
        //主线程等待t1、t2执行完成
        thread1.join();
        thread2.join();
        list.print();
    }
}

/**
 * MyList
 */
class MyList {
    //初始化成员变量array数组，初始化四个元素
    String[] array ={"a","b","",""};
    //初始化成员变量index
    int index = 2;

    //定义add方法，向array数组的index位置赋值变量
    public void add(String s){
        array[index]=s;
        try {
            //加个时间间隔，加大几率
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        index++;
    }
    //打印结果
    public void print(){
        for(int i=0;i<array.length;i++){
            System.out.println(array[i]);
        }
    }
}

以上代码会向MyList的array数组中插入元素，我们期望的结果是{“a”,“b”,“y”,“z”}或者{“a”,“b”,“z”,“y”},但是实际的运行结果却是{“a”,“b”,“y”,“”}或者{“a”,“b”,“z”,“”}。原因就是在执行add()方法的时候，其中一个线程赋值完array[index]=s，准备进行index++操作的时候，cpu时间片切换到了另外一个线程，重复为第三个元素进行了赋值，导致结果不是我们预期的结果。解决的办法是为void方法加上synchronized关键字使其变为同步方法。