Java--多线程

最新推荐文章于 2024-03-10 23:38:03 发布

Crystal_Mria

最新推荐文章于 2024-03-10 23:38:03 发布

阅读量192

点赞数

分类专栏： Java 文章标签： java

本文链接：https://blog.csdn.net/m0_37984616/article/details/80737874

版权

Java 专栏收录该内容

18 篇文章 0 订阅

订阅专栏

一些概念：

进程：正在运行的程序，是线程的集合；
线程：正在独立运行的一条执行程序；

同步：顺序执行；
异步：同时执行（多线程）；

守护线程：和main相关，和主线程一起销毁；
用户线程：用户自己创建的线程，如果主线程停止，不会影响用户；

实现多线程方式
1、继承Therad类，重写run()方法；
2、实现Runnable接口
为启动MyThread需先实例化一个Thread，并传入自己的MyThread实例；
3、实现Callable接口，通过FutureTask包装类来创建Therad线程
4、使用线程池来创建

线程池

// 线程池的构造方法
 public ThreadPoolExecutor(int corePoolSize,int maximumPoolSize,long keepAliveTime,TimeUnit unit,
        BlockingQueue<Runnable> workQueue,ThreadFactory threadFactory,RejectedExecutionHandler handler);

主要参数详解：
corePoolSize：核心池的大小；默认情况下，在创建了线程池后，线程池中的线程数为0，当有任务来之后，就会创建一个线程去执行任务，当线程池中的线程数目达到corePoolSize后，就会把到达的任务放到缓存队列当中；
maximumPoolSize：线程池最大线程数，它表示在线程池中最多能创建多少个线程；
keepAliveTime：表示线程没有任务执行时最多保持多久时间会终止。默认情况当线程池中的线程数大于corePoolSize时，如果一个线程空闲的时间达到keepAliveTime，则会终止，直到线程池中的线程数不超过corePoolSize。
unit：参数keepAliveTime的时间单位。
workQueue：一个阻塞队列，用来存储等待执行的任务。一般是这三种ArrayBlockingQueue、LinkedBlockingQueue、SynchronousQueue;
threadFactory：线程工厂，主要用来创建线程；
handler：表示当拒绝处理任务时的策略，有以下四种取值：
ThreadPoolExecutor.AbortPolicy:丢弃任务并抛出RejectedExecutionException异常。
ThreadPoolExecutor.DiscardPolicy：也是丢弃任务，但是不抛出异常。
ThreadPoolExecutor.DiscardOldestPolicy：丢弃队列最前面的任务，然后重新尝试执行任务（重复此过程）
ThreadPoolExecutor.CallerRunsPolicy：由调用线程处理该任务

ThreadPoolExecutor类中重要方法：
execute()
通过这个方法可以向线程池提交一个任务，交由线程池去执行。
submit()
这个方法也是用来向线程池提交任务的，但是它和execute()方法不同，它能够返回任务执行的结果，实际上还是调用的execute()方法，只不过它利用了Future来获取任务执行结果;
shutdown()
调用了shutdown()方法，则线程池处于SHUTDOWN状态，此时线程池不能够接受新的任务，它会等待所有任务执行完毕；
shutdownNow()
调用了shutdownNow()方法，则线程池处于STOP状态，此时线程池不能接受新的任务，并且会去尝试终止正在执行的任务；

线程池状态
当创建线程池后，初始时，线程池处于RUNNING状态；
当线程池处于SHUTDOWN或STOP状态，并且所有工作线程已经销毁，任务缓存队列已经清空或执行结束后，线程池被设置为TERMINATED状态。

线程池工作过程
1、如果当前线程池中的线程数目小于corePoolSize，则每来一个任务，就会创建一个线程去执行这个任务；
2、如果当前线程池中的线程数目>=corePoolSize，则每来一个任务，会尝试将其添加到任务缓存队列当中，若添加成功，则该任务会等待空闲线程将其取出去执行；若添加失败（一般来说是任务缓存队列已满），则会尝试创建新的线程去执行这个任务；
3、如果当前线程池中的线程数目达到maximumPoolSize，则会采取任务拒绝策略进行处理；
4、如果线程池中的线程数量大于 corePoolSize时，如果某线程空闲时间超过keepAliveTime，线程将被终止，直至线程池中的线程数目不大于corePoolSize；如果允许为核心池中的线程设置存活时间，那么核心池中的线程空闲时间超过keepAliveTime，线程也会被终止。

如果需要线程池创建之后立即创建线程，可以通过以下两个方法办到：
prestartCoreThread()：初始化一个核心线程；
prestartAllCoreThreads()：初始化所有核心线程

任务缓存队列及排队策略
　　workQueue的类型为BlockingQueue< Runnable >，通常可以取下面三种类型：
　　1）ArrayBlockingQueue：基于数组的先进先出队列，此队列创建时必须指定大小；
　　2）LinkedBlockingQueue：基于链表的先进先出队列，如果创建时没有指定此队列大小，则默认为Integer.MAX_VALUE；
　　3）synchronousQueue：这个队列比较特殊，它不会保存提交的任务，而是将直接新建一个线程来执行新来的任务。

线程池的关闭
shutdown()：不会立即终止线程池，而是要等所有任务缓存队列中的任务都执行完后才终止，但再也不会接受新的任务
shutdownNow()：立即终止线程池，并尝试打断正在执行的任务，并且清空任务缓存队列，返回尚未执行的任务

// 使用示例
public class Test {
     public static void main(String[] args) {   
         ThreadPoolExecutor executor = new ThreadPoolExecutor(5, 10, 200, TimeUnit.MILLISECONDS,
                 new ArrayBlockingQueue<Runnable>(5));
          
         for(int i=0;i<15;i++){
             MyTask myTask = new MyTask(i);
             executor.execute(myTask);
             System.out.println("线程池中线程数目："+executor.getPoolSize()+"，队列中等待执行的任务数目："+
             executor.getQueue().size()+"，已执行玩别的任务数目："+executor.getCompletedTaskCount());
         }
         executor.shutdown();
     }
}
 
 
class MyTask implements Runnable {
    private int taskNum;
     
    public MyTask(int num) {
        this.taskNum = num;
    }
     
    @Override
    public void run() {
        System.out.println("正在执行task "+taskNum);
        try {
            Thread.currentThread().sleep(4000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("task "+taskNum+"执行完毕");
    }
}

线程池excute()方法执行过程
这里写图片描述
源码：

public void execute(Runnable command) {
    if (command == null)
        throw new NullPointerException();
     
    /*
     * Proceed in 3 steps:
     *
     * 1. If fewer than corePoolSize threads are running, try to
     * start a new thread with the given command as its first
     * task.  The call to addWorker atomically checks runState and
     * workerCount, and so prevents false alarms that would add
     * threads when it shouldn't, by returning false.
     * 如果运行的线程少于corePoolSize，尝试开启一个新线程去运行command，command作为这个线程的第一个任务
     *
     * 2. If a task can be successfully queued, then we still need
     * to double-check whether we should have added a thread
     * (because existing ones died since last checking) or that
     * the pool shut down since entry into this method. So we
     * recheck state and if necessary roll back the enqueuing if
     * stopped, or start a new thread if there are none.
     * 如果任务成功放入队列，我们仍需要一个双重校验去确认是否应该新建一个线程（因为可能存在有些线程在我们上次检查后死了） 或者 从我们进入这个方法后，pool被关闭了
     * 所以我们需要再次检查state，如果线程池停止了需要回滚入队列，如果池中没有线程了，新开启 一个线程
     * 
     * 3. If we cannot queue task, then we try to add a new
     * thread.  If it fails, we know we are shut down or saturated
     * and so reject the task.
     * 如果无法将任务入队列（可能队列满了），需要新开区一个线程（自己：往maxPoolSize发展）
     * 如果失败了，说明线程池shutdown 或者 饱和了，所以我们拒绝任务
     */
    int c = ctl.get();
     
    /**
     * 1、如果当前线程数少于corePoolSize（可能是由于addWorker()操作已经包含对线程池状态的判断，如此处没加，而入workQueue前加了）
     */
    if (workerCountOf(c) < corePoolSize) {
        //addWorker()成功，返回
        if (addWorker(command, true))
            return;
         
        /**
         * 没有成功addWorker()，再次获取c（凡是需要再次用ctl做判断时，都会再次调用ctl.get()）
         * 失败的原因可能是：
         * 1、线程池已经shutdown，shutdown的线程池不再接收新任务
         * 2、workerCountOf(c) < corePoolSize 判断后，由于并发，别的线程先创建了worker线程，导致workerCount>=corePoolSize
         */
        c = ctl.get();
    }
     
    /**
     * 2、如果线程池RUNNING状态，且入队列成功
     */
    if (isRunning(c) && workQueue.offer(command)) {
        int recheck = ctl.get();//再次校验位
         
        /**
         * 再次校验放入workerQueue中的任务是否能被执行
         * 1、如果线程池不是运行状态了，应该拒绝添加新任务，从workQueue中删除任务
         * 2、如果线程池是运行状态，或者从workQueue中删除任务失败（刚好有一个线程执行完毕，并消耗了这个任务），确保还有线程执行任务（只要有一个就够了）
         */
        //如果再次校验过程中，线程池不是RUNNING状态，并且remove(command)--workQueue.remove()成功，拒绝当前command
        if (! isRunning(recheck) && remove(command))
            reject(command);
        //如果当前worker数量为0，通过addWorker(null, false)创建一个线程，其任务为null
        //为什么只检查运行的worker数量是不是0呢？？ 为什么不和corePoolSize比较呢？？
        //只保证有一个worker线程可以从queue中获取任务执行就行了？？
        //因为只要还有活动的worker线程，就可以消费workerQueue中的任务
        else if (workerCountOf(recheck) == 0)
            addWorker(null, false);  //第一个参数为null，说明只为新建一个worker线程，没有指定firstTask
                                     //第二个参数为true代表占用corePoolSize，false占用maxPoolSize
    }
    /**
     * 3、如果线程池不是running状态 或者 无法入队列
     *   尝试开启新线程，扩容至maxPoolSize，如果addWork(command, false)失败了，拒绝当前command
     */
    else if (!addWorker(command, false))
        reject(command);
}

参考：https://www.cnblogs.com/trust-freedom/p/6681948.html

线程优先级：
在Java线程中，通过一个整型成员变量priority来控制优先级，优先级的范围从1~10，在线
程构建的时候可以通过setPriority(int)方法来修改优先级。
注意：线程优先级不能作为程序正确性的依赖，因为操作系统可以完全不用理会Java
线程对于优先级的设定。
线程的状态：
线程状态图
Daemon线程是一种支持型线程，因为它主要被用作程序中后台调度以及支持性工作。这意味着，当一个Java虚拟机中不存在非Daemon线程的时候，Java虚拟机将会退出。可以通过调用Thread.setDaemon(true)将线程设置为Daemon线程。
注意：Daemon属性需要在启动线程之前设置，不能在启动线程之后设置。
构造线程

	private void init(ThreadGroup g, Runnable target, String name, long stackSize, AccessControlContext acc) {
		if (name == null) {
			throw new NullPointerException("name cannot be null");
		}
		// 当前线程就是该线程的父线程
		Thread parent = currentThread();
		this.group = g;
		// 将daemon、priority属性设置为父线程的对应属性
		this.daemon = parent.isDaemon();
		this.priority = parent.getPriority();
		this.name = name.toCharArray();
		this.target = target;
		setPriority(priority);
		// 将父线程的InheritableThreadLocal复制过来
		if (parent.inheritableThreadLocals != null)
			this.inheritableThreadLocals = ThreadLocal.createInheritedMap(parent.inheritableThreadLocals);
		// 分配一个线程ID
		tid = nextThreadID();
	}

启动线程：
线程start()方法的含义是：当前线程（即parent线程）同步告知Java虚拟机，只要线程规划器空闲，应立即启动调用start()方法的线程。
中断：
中断可以理解为线程的一个标识位属性，它表示一个运行中的线程是否被其他线程进行了中断操作。中断好比其他线程对该线程打了个招呼，其他线程通过调用该线程的interrupt()方法对其进行中断操作。
线程通过方法isInterrupted()来进行判断是否被中断，如果该线程已经处于终结状态，即使该线程被中断过，在调用该线程对象的isInterrupted()时依旧会返回false。
suspend()、resume()和stop()方法被标注为不建议使用的过期方法，而暂停和恢复操作可以用后面提到的等待/通知机制来替代。
安全地终止线程
中断操作是一种简便的线程间交互方式，而这种交互方式最适合用来取消或停止任务。除了中断以外，还可以利用一个boolean变量来控制是否需要停止任务并终止该线程。
volatile和synchronized关键字
关键字volatile可以用来修饰字段（成员变量），就是告知程序任何对该变量的访问均需要从共享内存中获取，而对它的改变必须同步刷新回共享内存，它能保证所有线程对变量访问的可见性。
关键字synchronized可以修饰方法或者以同步块的形式来进行使用，它主要确保多个线程在同一个时刻，只能有一个线程处于方法或者同步块中，它保证了线程对变量访问的可见性和排他性。

对于同步块的实现使用了monitorenter和monitorexit指令，而同步方法则是依靠方法修饰符上的ACC_SYNCHRONIZED来完成的。无论采用哪种方式，其本质是对一个对象的监视器monitor）进行获取，而这个获取过程是排他的，也就是同一时刻只能有一个线程获取到由synchronized所保护对象的监视器。
任意一个对象都拥有自己的监视器，当这个对象由同步块或者这个对象的同步方法调用时，执行方法的线程必须先获取到该对象的监视器才能进入同步块或者同步方法，而没有获取到监视器执行该方法）的线程将会被阻塞在同步块和同步方法的入口处，进入BLOCKED状态。
对象、监视器、同步队列
任意线程对Object（Object由synchronized保护）的访问，首先要获得Object的监视器。如果获取失败，线程进入同步队列，线程状态变为BLOCKED。当访问Object的前驱（获得了锁的线程）释放了锁，则该释放操作唤醒阻塞在同步队列中的线程，使其重新尝试对监视器的获取。

等待/通知机制

/**
 * 
 */
package chapter04;

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

/**
 * 6-11
 */
public class WaitNotify {
    static boolean flag = true;
    static Object  lock = new Object();

    public static void main(String[] args) throws Exception {
        Thread waitThread = new Thread(new Wait(), "WaitThread");
        waitThread.start();
        TimeUnit.SECONDS.sleep(1);

        Thread notifyThread = new Thread(new Notify(), "NotifyThread");
        notifyThread.start();
    }

    static class Wait implements Runnable {
        public void run() {
            // 加锁，拥有lock的Monitor
            synchronized (lock) {
                // 当条件不满足时，继续wait，同时释放了lock的锁
                while (flag) {
                    try {
                        System.out.println(Thread.currentThread() + " flag is true. wait @ "
                                           + new SimpleDateFormat("HH:mm:ss").format(new Date()));
                        lock.wait();
                    } catch (InterruptedException e) {
                    }
                }
                // 条件满足时，完成工作
                System.out.println(Thread.currentThread() + " flag is false. running @ "
                                   + new SimpleDateFormat("HH:mm:ss").format(new Date()));
            }
        }
    }

    static class Notify implements Runnable {
        public void run() {
            // 加锁，拥有lock的Monitor
            synchronized (lock) {
                // 获取lock的锁，然后进行通知，通知时不会释放lock的锁，
                // 直到当前线程释放了lock后，WaitThread才能从wait方法中返回
                System.out.println(Thread.currentThread() + " hold lock. notify @ " + new SimpleDateFormat("HH:mm:ss").format(new Date()));
                lock.notifyAll();
                flag = false;
                SleepUtils.second(5);
            }
            // 再次加锁
            synchronized (lock) {
                System.out.println(Thread.currentThread() + " hold lock again. sleep @ "
                                   + new SimpleDateFormat("HH:mm:ss").format(new Date()));
                SleepUtils.second(5);
            }
        }
    }
}

等待机制
WaitThread首先获取了对象的锁，然后调用对象的wait()方法，从而放弃了锁并进入了对象的等待队列WaitQueue中，进入等待状态。由于WaitThread释放了对象的锁，NotifyThread随后获取了对象的锁，并调用对象的notify()方法，将WaitThread从WaitQueue移到SynchronizedQueue，此时WaitThread的状态变为阻塞状态。NotifyThread释放了锁之后，WaitThread再次获取到锁并从wait()方法返回继续执行。
管道输入/输出流：
主要用于线程之间的数据传输，而传输的媒介为内存。
PipedOutputStream、PipedInputStream、PipedReader和PipedWriter，前两种面向字节，而后两种面向字符。对于Piped类型的流，必须先要进行绑定，也就是调用connect()方法
ThreadLocal，即线程变量，是一个以ThreadLocal对象为键、任意对象为值的存储结构。这个结构被附带在线程上，也就是说一个线程可以根据一个ThreadLocal对象查询到绑定在这个线程上的一个值。

/**
	Executors.newCachedThreadPool(); core是0，所有都可回收	
	Executors.newFixedThreadPool(); 固定大小，core = max，都不可回收
	Executors.newScheduledThreadPool();  定时任务的线程池
	Executors.newSingleThreadExecutor(); 单线程的线程池，后台从队列里面获取任务，挨个执行
 * */
/**
  * CompletableFuture 
	一 启动异步任务
	1 runAsync 开启异步线程处理任务，不会返回处理结果
	2 supplyAsync 开启异步线程处理任务，会返回处理结果
		1. .exceptionally 如果有异常 异常感知
		2. .handle 最终处理 可以修改返回值
		3. .whenComplete 可以接受处理结果和异常
	
	二 任务串行化
  *  1 thenRunAsync 不能获取上一步的执行结果，无返回值
  *      .thenRunAsync(()->{
  *             System.out.println("串行任务2 启动 ");
  *         });
  *  2 thenAcceptAsync 能获取上一步结果，无返回值
  *      .thenAcceptAsync(res->{
  *             System.out.println("串行任务2 启动 ");
  *         },);
  *  3 thenApplyAsync 能获取上一步结果，有返回值

	三 两任务组合-都要完成 
	*  两任务组合
    *  thenCombine 组合两个 future ，获取两个future 的结果，并返回当前任务的返回值
    *  thenAcceptBoth 组合两个 future，获取两个future 的结果，然后处理任务，没有返回值
    *  runAfterBoth 组合两个 future，不需要获取future的结果，只需要两个future处理完任务后处理该任务

 	四 两任务组合 一个future任务完成的时候执行任务
    * applyToEither 两个任务有一个执行完成，获取他的返回值，处理任务并没有新的返回值
    * acceptEither 两个任务有一个执行完成，获取他的返回值，处理任务，没有新的返回值
    * runAfterEither 两个任务有一个执行完成，不需要获取future的结果，处理任务，也没有返回值
    五 多任务组合
    allOf 等待所有任务完成
    anyOf 只要有一个任务完成
  */

  public static void main(String[] args) throws ExecutionException, InterruptedException {
		// 1 
        CompletableFuture<Void> future = CompletableFuture.runAsync(() -> {
            int i = 10 / 2;
            System.out.println(" 处理后的值 " + i);
        }, executor);
		// 完成回调 异常感知 
        CompletableFuture<Integer> integerCompletableFuture = CompletableFuture.supplyAsync(() -> {
            int i = 10 / 0;
            System.out.println("处理后的值 " + i);
            return i;
        }, executor).whenComplete((res,exception)->{ // 方法完成后的感知
            System.out.println("运行结果是  "+ res );
            System.out.println("异常是  "+ exception );
            // 如果有异常 异常感知
        }).exceptionally(exc->{
            return 10;
        });
    }
  // 最终处理 可以修改返回值
  public void test(){
  			CompletableFuture<Integer> integerCompletableFuture = CompletableFuture.supplyAsync(() -> {
            int i = 10 / 0;
            System.out.println("处理后的值 " + i);
            return i;
        }, executor).handle((res,exception)->{
            if (res != null) {
                return res*2;
            }
            if(exception != null){
                return 0;
            }
            return 0;
        });
        System.out.println("最终返回结果  " + integerCompletableFuture.get());

//  两任务组合。。。。。。。。。
CompletableFuture<Integer> future1 = CompletableFuture.supplyAsync(() -> {
            System.out.println("future1 开始");
            int i = 10 / 2;
            System.out.println("future1 结束");
            return i;
        }, executor);

        CompletableFuture<String> future2 = CompletableFuture.supplyAsync(() -> {
            System.out.println("future2 开始");
            System.out.println("future2 结束");
            return "hello";
        }, executor);
//        future1.runAfterBothAsync(future2,()->{
//            System.out.println("任务三 开始 ");
//        },executor);

//        future1.thenAcceptBothAsync(future2,(f1,f2)->{
//            System.out.println("任务三启动。。" + f1 +"...." + f2);
//        },executor);
        CompletableFuture<String> future3 = future1.thenCombineAsync(future2, (f1, f2) -> {
            return "任务三启动。。" + f1 + "...." + f2;
        }, executor);

//        future1.runAfterEitherAsync(future2,()->{
//            System.out.println("任务三启动。。");
//        },executor);
//        future1.acceptEither(future2,(res)->{
//            System.out.println("任务三启动。。" + res );
//        });

        CompletableFuture<String> future = future1.applyToEither(future2, (res) -> {
            return "任务三启动。。" + res + " hhe";
        });

   }

https://www.cnblogs.com/dolphin0520/p/3932921.html

Crystal_Mria

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java--多线程

线程优先级：在Java线程中，通过一个整型成员变量priority来控制优先级，优先级的范围从1~10，在线程构建的时候可以通过setPriority(int)方法来修改优先级。注意：线程优先级不能作为程序正确性的依赖，因为操作系统可以完全不用理会Java 线程对于优先级的设定。线程的状态： Daemon线程是一种支持型线程，因为它主要被用作程序中后台调度以及支持性工作。这...
复制链接

扫一扫