多线程相关

原创已于 2025-09-12 11:38:24 修改 · 797 阅读

20 ·

本内容遵循CC 4.0 BY-SA版权协议

GEO检测

标签

#java #开发语言

于 2024-11-10 17:38:33 首次发布

一、Thread

1.通过继承Thread类，重写run方法，调用start开启线程
2.直接new一个Thread类对象，传入一个Runnable对象，调用start开启线程

public class MyThread extends Thread
{
    @Override
    public void run() {
        System.out.println("PS--test Mythread");
    }
}

MyThread myThread = new MyThread();
myThread.start();
//测试以来Runnable接口
new Thread(new MyRunnable()).start();

二、Runnable

1.通过继承Runnable接口，重写run方法，传入Thread方法中调用start开启线程
2.直接new一个Runnable接口对象，传入Thread方法中调用start开启线程

public class MyThread extends Thread
{
    @Override
    public void run() {
        System.out.println("PS--test Mythread");
    }
}

public class MyRunnable implements Runnable {
    @Override
    public void run() {
        System.out.println("PS--test MyRunnable");
    }
}

//测试依赖Thread类
MyThread myThread = new MyThread();
myThread.start();
//测试以来Runnable接口
new Thread(new MyRunnable()).start();
//直接使用Runnable
new Thread(() -> System.out.println("PS--test Runnable interface")).start();
/**
*         同上：
*         new Thread(new Runnable() {
*             @Override
*             public void run() {
*                 System.out.println("PS--test Runnable interface");
*             }
*         }).start();
*/

三、线程池

1.简易方法创建

/**
 * 可缓存无界线程池测试
 * 当线程池中的线程空闲时间超过60s则会自动回收该线程，核心线程数为0
 * 当任务超过线程池的线程数则创建新线程。线程池的大小上限为Integer.MAX_VALUE，
 * 可看做是无限大。
 */
ExecutorService threadPoolExecutor1= Executors.newCachedThreadPool();

/**
 * 创建只有一个线程的线程池测试
 * 该方法无参数，所有任务都保存队列LinkedBlockingQueue中，核心线程数为1，线程空闲时间为0
 * 等待唯一的单线程来执行任务，并保证所有任务按照指定顺序(FIFO或优先级)执行
 */
ExecutorService threadPoolExecutor2= Executors.newSingleThreadExecutor();

/**
 * 创建固定线程数量的线程池测试
 * 创建一个固定大小的线程池，该方法可指定线程池的固定大小，对于超出的线程会在LinkedBlockingQueue队列中等待
 * 核心线程数可以指定，线程空闲时间为0
 */
ExecutorService threadPoolExecutor3= Executors.newFixedThreadPool(5);

/**
* 定时执行任务的线程池
* 创建指定核心线程数，最大线程数是Integer.MAX_VALUE
*/
ExecutorService threadPoolExecutor4= Executors.newScheduledThreadPool(3);
// 创建一个大小为 3 的定时执行任务的线程池
ScheduledThreadPoolExecutor executor = new ScheduledThreadPoolExecutor(3);
// 延迟 2 秒后执行任务
executor.schedule(() -> {
    System.out.println("Task 1 executed after 1 second");
}, 2, TimeUnit.SECONDS);
// 延迟 2 秒后开始执行任务，之后每隔 3 秒执行一次
executor.scheduleAtFixedRate(() -> {
    System.out.println("Task 2 executed at fixed rate of 3 seconds");
}, 2, 3, TimeUnit.SECONDS);
// 延迟 2 秒后开始执行任务，之后每隔 3 秒执行一次
executor.scheduleWithFixedDelay(() -> {
    System.out.println("Task 3 executed after 3 seconds on last task finished");
}, 2, 2, TimeUnit.SECONDS);

2.ThreadPoolEwector创建

线程池的七大参数：
1.核心线程数–corePoolSize
2.最大线程数–maximumPoolSize
当前线程数达到corePoolSize后，如果继续有任务被提交到线程池，会将任务缓存到工作队列中。如果队列也已满，则会去创建一个新线程*来出来这个处理，此时可创建的新线程数量由maximunPoolSize指定。
3.线程存活时间–keepAliveTime
一个线程如果处于空闲状态，并且当前的线程数量大于corePoolSize，那么在keepAliveTime时间后，这个空闲线程会被销毁
4.线程存活时间单位
5.工作队列–workQueue
新任务被提交后，会先进入到此工作队列中，任务调度时再从队列中取出任务。jdk中提供了四种工作队列：
①ArrayBlockingQueue
基于数组的有界阻塞队列，按FIFO排序。新任务进来后，会放到该队列的队尾，有界的数组可以防止资源耗尽问题。当线程池中线程数量达到corePoolSize后，再有新任务进来，则会将任务放入该队列的队尾，等待被调度。如果队列已经是满的，则创建一个新线程，如果线程数量已经达到maxPoolSize，则会执行拒绝策略。
②LinkedBlockingQueue
基于链表的无界阻塞队列（其实最大容量为Interger.MAX），按照FIFO排序。由于该队列的近似无界性，当线程池中线程数量达到corePoolSize后，再有新任务进来，会一直存入该队列，而基本不会去创建新线程直到maxPoolSize（很难达到Interger.MAX这个数），因此使用该工作队列时，参数maxPoolSize其实是不起作用的。
③SynchronousQueue
一个不缓存任务的阻塞队列，新任务进来时，不会缓存，而是直接被调度执行该任务，如果没有可用线程，则创建新线程，如果线程数量达到maxPoolSize，则执行拒绝策略。
④PriorityBlockingQueue
具有优先级的无界阻塞队列，优先级通过参数Comparator实现。
6.线程工厂–threadFactory
默认工厂 Executors.defaultThreadFactory()
7.拒接策略–handler
当工作队列中的任务已到达最大限制，并且线程池中的线程数量也达到最大限制，这时如果有新任务提交进来则只需拒绝策略
①CallerRunsPolicy
在调用者线程中直接执行被拒绝任务的run方法，除非线程池已经shutdown，则直接抛弃任务。
②AbortPolicy
直接丢弃任务，并抛出RejectedExecutionException异常。
③DiscardPolicy
直接丢弃任务，什么都不做。
④DiscardOldestPolicy
抛弃进入队列最早的那个任务，然后尝试把这次拒绝的任务放入队列

ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor (3,8,50,
        TimeUnit.MILLISECONDS,
        new ArrayBlockingQueue<>(10),
        Executors.defaultThreadFactory(),
        new ThreadPoolExecutor.CallerRunsPolicy());
for(int i=0; i<50; i++) {
    threadPoolExecutor.execute(new MyRunnable());
}

提交线程任务：
execute()方法用于提交不需要返回值的任务，所以无法判断任务是否被线程池执行成功与否；
submit()方法用于提交需要返回值的任务。线程池会返回一个 Future 类型的对象，通过这个 Future 对象可以判断任务是否执行成功，并且可以通过 Future 的 get()方法来获取返回值，get()方法会阻塞当前线程直到任务完成，而使用 get（long timeout，TimeUnit unit）方法则会阻塞当前线程一段时间后立即返回，这时候有可能任务没有执行完。
关闭线程池：
shutdown()关闭线程池，线程池的状态变为 SHUTDOWN。线程池不再接受新任务了，但是队列里的任务得执行完毕。
shutdownNow()关闭线程池，线程的状态变为 STOP。线程池会终止当前正在运行的任务，并停止处理排队的任务并返回正在等待执行的 List。

四、异步代码顺序执行

多个线程异步执行时使多个线程按照先后顺序同步执行。

1.通过join方式

val thread1 = Thread {
    Log.d("111111", "111111")
}
val thread2 = Thread {
    Log.d("111111", "222222")
}
val thread3 = Thread {
    Log.d("111111", "333333")
}
thread1.start()
thread1.join()
thread2.start()
thread2.join()
thread3.start()
thread3.join()

2.通过线程池

val thread1 = Thread {
    Log.d("111111", "111111")
}
val thread2 = Thread {
    Log.d("111111", "222222")
}
val thread3 = Thread {
    Log.d("111111", "333333")
}
val executor = Executors.newSingleThreadExecutor()//创建单个线程的线程池
executor.submit(thread1)
executor.submit(thread2)
executor.submit(thread3)
executor.shutdown()//关闭

五、android中的Handler

1. handler.sendMessage

传递Message信息

//PlanEvent EventListener基本定义，此处不再赘述

object EventHandler
{
    private const val TAG = "EventHandler"
    //子线程Handler
    private val eventListeners = listOf<EventListener>().toMutableList()
    private val workThread: HandlerThread = HandlerThread("EventHandler thread").apply {
    	start()
    }
    private var innerEventHandler = object : Handler(workThread.looper) {
         override fun handleMessage(msg: Message) {
            super.handleMessage(msg)
            val bundleData: Bundle = msg.data
            val originalText = bundleData.getString("originalText")
            val source = bundleData.getString("source")
            val planEvent = PlanEvent(originalText,source!!)
            synchronized(eventListeners) {
                eventListeners.forEach { it.onEventData(planEvent) }
            }
            Log.d(TAG, "event data: $planEvent")
        }
    }
    fun sendMessage(msg: Message) {
        innerEventHandler.sendMessage(msg)
    }
    fun addEventListener(listener: EventListener) {
        synchronized(eventListeners) {
            eventListeners.add(listener)
        }
    }
    fun removeEventListener(listener: EventListener) {
        synchronized(eventListeners) {
            eventListeners.remove(listener)
        }
    }
}

2.handler.post

post(Runnable runnable)方法接受一个Runnable对象，且runnable的run方法中的操作可在主线程更新，例如执行ui操作
post方法不用调用start

val handler = Handler()
mRunnable = object:Runnable {//可转化为Lambda表达式
    override fun run() {
        mChangeValue++
        mListener?.onChanged(mChangeValue)
        handler.postDelayed(mRunnable, 2000)//实现一直定时功能
    }
}
handler.postDelayed(mRunable,2000)