多线程简洁版

Posted 2020-10-28 maopneo

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了多线程简洁版相关的知识，希望对你有一定的参考价值。

多线程技术分享

背景：

以前单CPU，单任务的条件下，一段时间只能执行单一的程序。之后发展到多任务阶段。多个任务共享一个CPU，本质上是有操作系统来完成CPU对多个用户的切换。保证每个任务都有一定的时间片来完成任务。

1. 概念和原理

进程是指一个内存中运行的应用程序，每个进程都有自己独立的一块内存空间，一个进程中可以启动多个线程。

线程是指进程中的一个执行流程，一个进程中可以运行多个线程。线程总是属于某个进程，进程中的多个线程共享进程的内存。

2. 线程的两种实现方法

1、扩展java.lang.Thread类。

此类中有个run()方法，应该注意其用法：

public void run()

如果该线程是使用独立的 Runnable 运行对象构造的，则调用该 Runnable 对象的 run 方法；否则，该方法不执行任何操作并返回。

Thread 的子类应该重写该方法。

2、实现java.lang.Runnable接口。

void run()

使用实现接口 Runnable 的对象创建一个线程时，启动该线程将导致在独立执行的线程中调用对象的 run 方法。

方法 run 的常规协定是，它可能执行任何所需的操作。

两种方式的区别：既然都能实现线程的功能，怎样区别使用呢。java规定只能单继承，如果自定义类需要继承其他类，只能选择实现Runnable接口。

3. 线程的理解

线程继承Thread 或者实现Runnable接口。既然是线程，就必然有写的run方法，其次，多线程是多个线程处理公共的资源，所以，每个线程都共享公用资源，所以每个线程里面都有同一个资源对象。通常，公共资源有线程的构造方法传递的。如下，共享资源pendingIfData。

/**
* 接口调用线程
*
* @author maoping
*
*/
public class ThreadIfExcuse extends Thread {
// 线程名称
10. private String threadName;
11.
12. // 待处理接口数据公共类
13. private PendingIfData pendingIfData;
14.
15. ThreadIfExcuse(String threadName, PendingIfData pendingIfData) {
16. this.threadName = threadName;
17. this.pendingIfData = pendingIfData;
18.
19. }
20.
21. @Override
22. public void run() {
23. while (true) {
24. pendingIfData.ifExcuse(threadName);
25. }
26.
27. }
28.

29. }

详细描述共享资源的内容。实现互斥操作的方式有多种，实例中使用await / signal来控制。一般而言，公用共享资源类中包含

数据共享的存储介质，需要线程安全，本示例中为LinkedBlockingQueue类型的interfaceUUIDQueue 。

互斥执行方法fExcuse (进入方法使用lock将代码锁住，使用条件condition的await，让代码线程处于等待状态。然后是从数据共享的存储介质中获取待处理数据，然后执行互斥的业务方法。最后lock解锁（lock.unlock）。

唤醒方法：如果是一个类调用唤醒方法，则是简单的多线程处理，如果是多个线程调用唤醒方法，则为生产者，消费者，仓库模型了。唤醒方法的详情。首先lock锁定，其次给共享的存储介质中加入待处理数据单元，然后唤醒添加下等待的线程同时醒来进行一次控制权抢夺。其中一个获取控制权去处理一个数据。

/**
* 待处理接口数据线程
*
* @author maoping
*
*/
public class PendingIfData {
private ReentrantLock lock = new ReentrantLock();
10.
11. private Condition condition = lock.newCondition();
12.
13. private LinkedBlockingQueue<String> interfaceUUIDQueue = new LinkedBlockingQueue<String>();
14.
15. // condition 必须在lock锁范围内
16. public void ifExcuse(String threadName) {
17.
18. try {
19. lock.lock();
20. condition.await();
21. // 接口调用
22. String IfUUID = interfaceUUIDQueue.take();
23. // 静态类不能注入服务需要使用getBean方式回去服务类
24. IfExcuseService ifExcuseService = new IfExcuseService();
25. ifExcuseService.ifExcuse(IfUUID);
26. } catch (InterruptedException e) {
27. // TODO Auto-generated catch block
28. e.printStackTrace();
29. } finally {
30. lock.unlock();
31. }
32.
33. }
34.
35. /**
36. * 添加待调用的线程UUID 并激活等待线程
37. *
38. * @param IfUUID
39. */
40. public void putIfUUID(String IfUUID) {
41.
42. lock.lock();
43. try {
44. System.out.println("添加待调用接口UUID 激活调用线程 ... ...");
45. interfaceUUIDQueue.put(IfUUID);
46. condition.signal();
47. } catch (InterruptedException e) {
48. e.printStackTrace();
49. }
50. lock.unlock();
51.
52. }
53.

54. }

4. 线程状态的切换

线程的状态转换是线程控制的基础。线程状态总的可分为五大状态：分别是生、死、可运行、运行、等待/阻塞。用一个图来描述如下：

新建状态（New）：当线程对象对创建后，即进入了新建状态，如：Thread t = new MyThread();

就绪状态（Runnable）：当调用线程对象的start()方法（t.start();），线程即进入就绪状态。处于就绪状态的线程，只是说明此线程已经做好了准备，随时等待CPU调度执行，并不是说执行了t.start()此线程立即就会执行；

运行状态（Running）：当CPU开始调度处于就绪状态的线程时，此时线程才得以真正执行，即进入到运行状态。注：就绪状态是进入到运行状态的唯一入口，也就是说，线程要想进入运行状态执行，首先必须处于就绪状态中；

阻塞状态（Blocked）：处于运行状态中的线程由于某种原因，暂时放弃对CPU的使用权，停止执行，此时进入阻塞状态，直到其进入到就绪状态，才有机会再次被CPU调用以进入到运行状态。根据阻塞产生的原因不同，阻塞状态又可以分为三种：

1.等待阻塞：运行状态中的线程执行wait()方法，使本线程进入到等待阻塞状态；

2.同步阻塞 -- 线程在获取synchronized同步锁失败(因为锁被其它线程所占用)，它会进入同步阻塞状态；

3.其他阻塞 -- 通过调用线程的sleep()或join()或发出了I/O请求时，线程会进入到阻塞状态。当sleep()状态超时、join()等待线程终止或者超时、或者I/O处理完毕时，线程重新转入就绪状态。

死亡状态（Dead）：线程执行完了或者因异常退出了run()方法，该线程结束生命周期。

线程在Running的过程中可能会遇到阻塞(Blocked)情况

调用join()和sleep()方法，sleep()时间结束或被打断，join()中断,IO完成都会回到Runnable状态，等待JVM的调度。
调用wait()，使该线程处于等待池(wait blocked pool),直到notify()/notifyAll()，线程被唤醒被放到锁定池(lock blocked pool )，释放同步锁使线程回到可运行状态（Runnable）
对Running状态的线程加同步锁(Synchronized)使其进入(lock blocked pool ),同步锁被释放进入可运行状态(Runnable)。

此外，在runnable状态的线程是处于被调度的线程，此时的调度顺序是不一定的。Thread类中的yield方法可以让一个running状态的线程转入runnable。

5. 线程的各种机制下的示例

任务场景：一个机构有1000替代币（类似比特币），每次放出20个比特币，放币的时间间隔为次数*3秒，放完为止。三个矿工集团（A、B、C）使用计算机挖比特币。

用一个线程模拟机构，按照时间规律放替代币，另外三个线程模拟三个矿工公司挖替代币。

公共服务数据类
/**
* 数据共享服务
*
* @author maoping
*
*/
public class MyCommonData {
10. // 锁
11. private ReentrantLock lock = new ReentrantLock();
12.
13. // 条件
14. private Condition condition = lock.newCondition();
15.
16. // 仓库
17. private LinkedBlockingQueue<Integer> bitMoneyQueue = new LinkedBlockingQueue<Integer>();
18.
19. // 矿工挖到比特币
20. public void getBitMoney(String threadName) {
21. try {
22. lock.lock();
23. condition.await();// 处于阻塞状态
24. Integer moneyCode = bitMoneyQueue.take();// 比特币编码
25. System.out.println(threadName + " 挖到了比特币，编码为：" + moneyCode);
26. } catch (InterruptedException e) {
27. e.printStackTrace();
28. } finally {
29. lock.unlock();
30. }
31. }
32.
33. public void createBitCoin(Integer bitCoinCode) {
34. try {
35. lock.lock();
36. bitMoneyQueue.put(bitCoinCode);
37. condition.signal();
38. } catch (InterruptedException e) {
39. e.printStackTrace();
40. } finally {
41. lock.unlock();
42. }
43.
44. }
45.

46. }

2.生产数据类（此处使用单线程模拟不断生成新的比特币）

/**
* 创建替代币公司
*
* @author maoping
*
*/
public class CreateBitCoinThread extends Thread {
// 共享数据
10. private MyCommonData commonData;
11.
12. private int count = 0;
13.
14. CreateBitCoinThread(MyCommonData commonData) {
15. this.commonData = commonData;
16.
17. }
18.
19. @Override
20. public void run() {
21. System.out.println("begin ...");
22. long nextCreateBitCoinTime = System.currentTimeMillis();
23. long2date("首次时间为 ", nextCreateBitCoinTime);
24. while (true) {
25. if (count <= 500 && nextCreateBitCoinTime < System.currentTimeMillis()) {
26. for (int i = 0; i < 20; i++) {
27. System.out.println("");
28. commonData.createBitCoin(count * 20 + i + 1);
29. }
30. nextCreateBitCoinTime += ((count + 1) * 1000) * 10;
31. long2date("下次时间为 ", nextCreateBitCoinTime);
32. count++;
33. }
34. }
35. }
36.
37. private void long2date(String str, long dateTime) {
38. SimpleDateFormat sdf = new SimpleDateFormat("MM/dd/yyyy HH:mm:ss");
39. java.util.Date dt = new Date(dateTime);
40. String sDateTime = sdf.format(dt); // 得到精确到秒的表示：08/31/2006 21:08:00
41. System.out.println(str + " " + sDateTime);
42. }
43.

44. }

3.多线程消费数据类

/**
* 创建替代币公司
*
* @author maoping
*
*/
public class CreateBitCoinThread extends Thread {
// 共享数据
10. private MyCommonData commonData;
11.
12. private int count = 0;
13.
14. CreateBitCoinThread(MyCommonData commonData) {
15. this.commonData = commonData;
16.
17. }
18.
19. @Override
20. public void run() {
21. System.out.println("begin ...");
22. long nextCreateBitCoinTime = System.currentTimeMillis();
23. long2date("首次时间为 ", nextCreateBitCoinTime);
24. while (true) {
25. if (count <= 500 && nextCreateBitCoinTime < System.currentTimeMillis()) {
26. for (int i = 0; i < 20; i++) {
27. System.out.println("");
28. commonData.createBitCoin(count * 20 + i + 1);
29. }
30. nextCreateBitCoinTime += ((count + 1) * 1000) * 10;
31. long2date("下次时间为 ", nextCreateBitCoinTime);
32. count++;
33. }
34. }
35. }
36.
37. private void long2date(String str, long dateTime) {
38. SimpleDateFormat sdf = new SimpleDateFormat("MM/dd/yyyy HH:mm:ss");
39. java.util.Date dt = new Date(dateTime);
40. String sDateTime = sdf.format(dt); // 得到精确到秒的表示：08/31/2006 21:08:00
41. System.out.println(str + " " + sDateTime);
42. }
43.

44. }

main方法主类

/**
* main 方法主类
*
* @author maoping
*
10. */

11. public class MainTest {

12.
13. public static void main(String[] args) {
14.
15. MyCommonData commonData = new MyCommonData();
16. new Thread(new CreateBitCoinThread(commonData)).start();
17. // 矿工挖矿
18. new Thread(new DigBitcoinThread(commonData, "挖矿公司 A")).start();
19. new Thread(new DigBitcoinThread(commonData, "挖矿公司 B")).start();
20. new Thread(new DigBitcoinThread(commonData, "挖矿公司 C")).start();
21.
22. }
23.

24. }

运行结果类
begin ...
首次时间为 03/26/2018 09:23:37
挖矿公司 A 挖到了比特币，编码为：1
挖矿公司 B 挖到了比特币，编码为：2
挖矿公司 C 挖到了比特币，编码为：3
挖矿公司 A 挖到了比特币，编码为：4
挖矿公司 B 挖到了比特币，编码为：5
挖矿公司 C 挖到了比特币，编码为：6
挖矿公司 A 挖到了比特币，编码为：7
挖矿公司 B 挖到了比特币，编码为：8
挖矿公司 C 挖到了比特币，编码为：9
挖矿公司 A 挖到了比特币，编码为：10
挖矿公司 B 挖到了比特币，编码为：11
挖矿公司 C 挖到了比特币，编码为：12
挖矿公司 A 挖到了比特币，编码为：13
挖矿公司 B 挖到了比特币，编码为：14
挖矿公司 C 挖到了比特币，编码为：15
挖矿公司 A 挖到了比特币，编码为：16
挖矿公司 B 挖到了比特币，编码为：17
挖矿公司 C 挖到了比特币，编码为：18
挖矿公司 A 挖到了比特币，编码为：19
挖矿公司 B 挖到了比特币，编码为：20
下次时间为 03/26/2018 09:23:47
-----------------------
挖矿公司 C 挖到了比特币，编码为：21
挖矿公司 A 挖到了比特币，编码为：22
挖矿公司 B 挖到了比特币，编码为：23
挖矿公司 C 挖到了比特币，编码为：24
挖矿公司 A 挖到了比特币，编码为：25
挖矿公司 B 挖到了比特币，编码为：26
挖矿公司 C 挖到了比特币，编码为：27
挖矿公司 A 挖到了比特币，编码为：28
挖矿公司 B 挖到了比特币，编码为：29
挖矿公司 C 挖到了比特币，编码为：30
挖矿公司 A 挖到了比特币，编码为：31
挖矿公司 B 挖到了比特币，编码为：32
挖矿公司 C 挖到了比特币，编码为：33
挖矿公司 A 挖到了比特币，编码为：34
挖矿公司 B 挖到了比特币，编码为：35
挖矿公司 C 挖到了比特币，编码为：36
挖矿公司 A 挖到了比特币，编码为：37
下次时间为 03/26/2018 09:24:07
-----------------------------
挖矿公司 B 挖到了比特币，编码为：38
挖矿公司 C 挖到了比特币，编码为：39
挖矿公司 A 挖到了比特币，编码为：40

100.挖矿公司 B 挖到了比特币，编码为：41

102.挖矿公司 C 挖到了比特币，编码为：42

105.挖矿公司 A 挖到了比特币，编码为：43

106.挖矿公司 B 挖到了比特币，编码为：44

108.挖矿公司 C 挖到了比特币，编码为：45

110.挖矿公司 A 挖到了比特币，编码为：46

112.挖矿公司 B 挖到了比特币，编码为：47

114.挖矿公司 C 挖到了比特币，编码为：48

116.挖矿公司 A 挖到了比特币，编码为：49

118.挖矿公司 B 挖到了比特币，编码为：50

120.挖矿公司 C 挖到了比特币，编码为：51

122.挖矿公司 A 挖到了比特币，编码为：52

124.挖矿公司 B 挖到了比特币，编码为：53

126.挖矿公司 C 挖到了比特币，编码为：54

128.挖矿公司 A 挖到了比特币，编码为：55

130.挖矿公司 B 挖到了比特币，编码为：56

131.挖矿公司 C 挖到了比特币，编码为：57

132.下次时间为 03/26/2018 09:24:37

由结果可以看出，每次放出20个比特币，且每次放出时间间隔逐渐变成，第一次间隔10s 第二次间隔20s，第三次间隔30s 依次重复。且每次放出的20个比特币被三个挖矿公司挖走。3个挖矿公司为相互竞争每次放出固定数量的比特币。比特币只能被其中的一个公司挖走。使用多线程描述这一情景。

以上是关于多线程简洁版的主要内容，如果未能解决你的问题，请参考以下文章

Python 多线程多进程 GIL

ServerSocketChannel实现多Selector高并发server

多线程简洁版

Qt: 多线程, 就是这么简单（确实非常简洁明了）

初识单例模式

多线程 简洁版

多线程技术分享

背景：

1. 概念和原理

2. 线程的两种实现方法

3. 线程的理解

4. 线程状态的切换

5. 线程的各种机制下的示例

多线程简洁版