併發專題（一）--初識多線程的發展及應用

時間 2019-11-16

標籤併發專題識多線程發展應用简体版

原文原文鏈接

1、併發編程的發展歷史

　　併發設計主導者 Doug Leajava

　　談談學習方法算法

　　　　1.場景-->需求-->解決方案-->應用-->原理編程

　　　　　　案例：多線程

　　　　　　　　1.1 併發併發的場景是爲了提升程序的吞吐性能及實時性
　　　　　　　　1.2 dubbo 在分佈式環境下，存在服務治理的需求，採用的解決方案就是dubbo，首先知道如何去應用他，進而去了解它的原理併發

　　　　　　　　1.3 JVM 一次編譯處處運行，存在這跨平臺的需求，而不一樣的操做系統平臺之間存在這巨大的差別，如何解決這種差別，就在操做系統和咱們的應用軟件之間架設一層虛擬的操做系統，即JVM，而如何去應用，就是安裝JDK，經過虛擬機將虛擬機語言編譯成支持跨平臺字節碼，而後去運行。而想要更加靈活地去運用，就要去了解JVM的底層原理，包括他的內存結構，垃圾回收機制，垃圾回收機制算法等。異步

　　隨着硬件的演變，軟件隨之演變socket

　　1.真空管/穿孔打卡

　　　　最先是爲了解決數學計算問題。在卡片輸入以前計算機大部分處理空閒狀態。分佈式

　　2.晶體管/批處理操做系統

　　　　好處是工做時，計算機不須要等待，能夠解決計算機空閒問題。但同時也存在了新的問題，那就是IO問題，一旦在處理一個指令或者計算時形成阻塞，就會形成CPU的資源浪費。ide

　　　　那麼就會產生一個需求-->若是最大化利用CPU資源?性能

　　3.集成電路/多道程序設計

　　　　進程的出現，使得內存空間被分紅多個互不影響的空間，若是進程A阻塞，並不妨礙進程B的運行。在用戶層面看是併發的，但在CPU層面是進行了時間片的切換。而在切換的過程過會記錄進程的位置。

　　4.最後引出咱們的豬腳--線程？

　　　　1.單核->多核->真正意義上的達到並行計算。

　　　　　　在不一樣的CPU中處理相同的計算機指令。

　　　　2.真正意義上的需求--實時性。

　　　　　　在一個進程中會出現多個任務。如何保證多個任務是實時性的。輕量級的進程，線程使得CPU切換的成本更低。在多核時代資源利用率更高。

　　　　3.線程能夠合理的利用多核心的CPU資源，提升程序的吞吐量

2、線程在java中的應用

　　1.如何在java中實現線程？

　　　　1.1 Runnable接口

　　　　1.2 Thread類（本質上是對Runnable接口的實現）

　　　 1.3 Callable/Future 帶返回值的線程()

　　　　 1.4 TheadPool　

3、多線程的實際應用場景

　　1.線程池，new Thread() 會形成咱們對資源的不可控。

　　　　財務類：文件跑批，收益文件，對帳文件。

　　　　BIO模型優化　　　　

1 Socket socket = socket.accept();    //鏈接阻塞
2 
3 socket = socket.inputsteam();        //讀取阻塞
4 socket = socket.outputsteam();      //寫入阻塞
5 
6 //解決方式
7 new Thread(new Handler(socket)).start(); //解決了r/w阻塞問題。

BIO模型優化

　　　　zookepper責任鏈模型

  1 package com.jlDemo.ConcurrentFirstChapter.ThreadDemo;
  2 
  3 /**
  4  * @author jar luo
  5  * @time 2019.4.22
  6  */
  7 public class Request {
  8     private String name;
  9 
 10     public String getName() {
 11         return name;
 12     }
 13 
 14     public void setName(String name) {
 15         this.name = name;
 16     }
 17 
 18     @Override
 19     public String toString() {
 20         return "Request{" +
 21                 "name='" + name + '\'' +
 22                 '}';
 23     }
 24 }
 25 
 26 package com.jlDemo.ConcurrentFirstChapter.ThreadDemo;
 27 /**
 28  * @author jar luo
 29  *
 30  * @time  2019.4.22
 31  */
 32 public interface RequestProcessor {
 33 
 34     void processorRequest(Request request);
 35 
 36 }
 37 
 38 
 39 package com.jlDemo.ConcurrentFirstChapter.ThreadDemo;
 40 
 41 import java.util.concurrent.LinkedBlockingQueue;
 42 
 43 /**
 44  * @author jar luo
 45  * @time 2019.4.22
 46  * @desc 打印請求的內容--借鑑zk的責任鏈思想
 47  */
 48 public class PrintProcesser extends Thread implements RequestProcessor {
 49 
 50     LinkedBlockingQueue<Request> linkedBlockingQueue = new LinkedBlockingQueue();
 51 
 52     private final RequestProcessor nextProcessor;
 53 
 54     public PrintProcesser(RequestProcessor nextProcessor) {
 55         this.nextProcessor = nextProcessor;
 56     }
 57 
 58     @Override
 59     public void run() {
 60         while (true){
 61             try {
 62                 Request request = linkedBlockingQueue.take();
 63                 System.out.println("print data:" + request);
 64                 nextProcessor.processorRequest(request);
 65             } catch (InterruptedException e) {
 66                 e.printStackTrace();
 67             }
 68         }
 69     }
 70 
 71     @Override
 72     public void processorRequest(Request request) {
 73         linkedBlockingQueue.add(request);
 74     }
 75 }
 76 
 77 
 78 package com.jlDemo.ConcurrentFirstChapter.ThreadDemo;
 79 
 80 import java.util.concurrent.LinkedBlockingQueue;
 81 
 82 /**
 83  *
 84  */
 85 public class SaveProcessor extends Thread implements RequestProcessor{
 86 
 87     LinkedBlockingQueue<Request> linkedBlockingQueue = new LinkedBlockingQueue();
 88 
 89 
 90     @Override
 91     public void run() {
 92         while (true){
 93             try {
 94                 Request request = linkedBlockingQueue.take();
 95                 System.out.println("save data:" + request);
 96             } catch (InterruptedException e) {
 97                 e.printStackTrace();
 98             }
 99         }
100     }
101 
102     @Override
103     public void processorRequest(Request request) {
104         linkedBlockingQueue.add(request);
105     }
106 }
107 
108 
109 package com.jlDemo.ConcurrentFirstChapter.ThreadDemo;
110 
111 /**
112  *
113  */
114 public class Demo {
115 
116     PrintProcesser printProcesser ;
117 
118     public Demo() {
119         SaveProcessor saveProcessor = new SaveProcessor();
120         saveProcessor.start();
121         printProcesser = new PrintProcesser(saveProcessor);
122         printProcesser.start();
123     }
124 
125 
126 
127     public static void main(String[] args) {
128         Request request = new Request();
129         request.setName("jar luo");
130         new Demo().doTest(request);
131     }
132 
133     public void doTest(Request request){
134         printProcesser.processorRequest(request);
135     }
136 
137 
138 }
139 
140 ThreadDemo