国产xxxx99真实实拍_久久不雅视频_高清韩国a级特黄毛片_嗯老师别我我受不了了小说

資訊專欄INFORMATION COLUMN

并發學習筆記（1）

objc94 / 3414人閱讀

摘要：共享數據使線程之間的通信比進程之間的通信更有效。并發模型和的區別說明的作用是啟動一個新線程操作系統級別，有一個方法啟動新線程，新線程會執行相應的方法。多帶帶調用會在當前線程中執行并不會啟動新線程創建一個線程即可但是這個線程沒有執行任何代碼段。

tutorials site

并發Concurrency發展的歷史 
     單CPU，一次只能運行一個程序 -- 多任務，一次同時運行多個任務 （問題是每個任務不能永遠占有資源或者CPU，不再使用資源或者CPU的程序需要釋放掉自己的資源） -- 多線程，每個任務都有多線程進行處理，每個執行著的線程都可以當做是一個CPU。（問題是 每個線程都執行相同的任務，因此同時讀和寫同一段內存，這會導致單線程不能出現的問題）
     舉個例子： 如果一個線程讀了一塊內存 同時發生了另一個線程寫到了這塊內存。那么第一個線程讀到的是什么? old value or the value just wriiten or a value mid between the two. 如果更多的線程同時寫到了這個內存，第一個線程讀到什么。
     Therefore it is important as a developer to know how to take the right precautions - meaning learning to control how threads access shared resources like memory, files, databases etc. That is one of the topics this Java concurrency tutorial addresses.

多進程和多線程的區別？
本質的區別在于每個進程擁有自己的一整套變量，而線程則共享數據。共享數據使線程之間的通信比進程之間的通信更有效。

此外在有些操作系統中，與進程相比較，線程更加輕量級，創建，撤銷一個線程比啟動線程開銷要小很多。

棧的組成

JVM 的內存模型 可以分為調用棧，堆，方法區，寄存器，本地方法棧；其中主要組成是前二。

同一進程中的多條線程將共享該進程中的全部系統資源，如虛擬地址空間，文件描述符和信號處理等等。但同一進程中的多個線程有各自的調用棧（call stack），自己的寄存器環境（register context），自己的線程本地存儲（thread-local storage）

每一個在JVM中運行的線程都有自己的調用棧call stack, 調用棧存儲著該線程調用了哪些方法以及這些方法的局部變量。每個棧只能查看自己的局部變量，無法查看其它棧的局部變量。

  
Objects on the heap can be accessed by all threads that have a reference to the object. When a thread has access to an object, it can also get access to that object"s member variables. If two threads call a method on the same object at the same time, they will both have access to the object"s member variables, but each thread will have its own copy of the local variables.


　advantage and disadvantage

使用并發的好處：

* 更好的資源利用率
* 更精簡的程序設計（一個線程負責讀，一個線程負責寫，一個線程只做一個功能，這樣程序設計精簡多了）
* 更多響應的程序 （服務器監聽線程，處理線程的例子）

使用并發的代價：

* 設計更復雜

Code executed by multiple threads accessing shared data need special attention. Thread interaction is far from always simple. Errors arising from incorrect thread synchronization can be very hard to detect, reproduce and fix.

* 上下文切換

When a CPU switches from executing one thread to executing another, the CPU needs to save the local data, program pointer etc. of the current thread, and load the local data, program pointer etc. of the next thread to execute. This switch is called a "context switch".

* 消耗資源

CPU需要額外的空間時間去維護一個線程。

并發模型

Creating and Starting java threads

start 和 run的區別說明

* start() 的作用是 啟動一個新線程（操作系統級別，有一個native方法start0() 啟動新線程），新線程會執行相應的run方法。
* run() 和普通的成員方法一樣，可以被重復調用。 多帶帶調用run() 會在當前線程中執行run() 并不會啟動新線程

創建一個線程Thread thread = new Thread(); thread.start() 即可
但是這個線程沒有執行任何代碼段。

有兩種方式可以指定哪段代碼 一個線程會執行。

繼承Thread - Thread Subclass

java  public class MyThread extends Thread {

    public void run(){
       System.out.println("MyThread running");
    }
  }

To create and start the above thread you can do like this:

java  MyThread myThread = new MyThread();
  myTread.start();

覆蓋run方法 - Runnable Interface Implemention
第二種方式指定線程應該運行那端代碼 是創建一個類執行java.lang.Runnable接口

  public class MyRunnable implements Runnable {

    public void run(){
       System.out.println("MyRunnable running");
    }
  }

To have the run() method executed by a thread, pass an instance of MyRunnable to a Thread in its constructor. Here is how that is done:

Thread thread = new Thread(new MyRunnable());
thread.start();
Race Conditions and Critical Sections 
  
The problems arise when multiple threads access the same resources.For instance the same memory (variables, arrays, or objects), systems (databases, web services etc.) or files. In fact, problems only arise if one or more of the threads write to these resources. It is safe to let multiple threads read the same resources, as long as the resources do not change.


  
The situation where two threads compete for the same resource, where the sequence in which the resource is accessed is significant, is called race conditions. A code section that leads to race conditions is called a critical section. In the previous example the method add() is a critical section, leading to race conditions. Race conditions can be avoided by proper thread synchronization in critical sections.
Thread Safety and Shared Resources 
  
Code that is safe to call by multiple threads simultanously is called thread safe. If a piece of code is thread safe, then it contains no race conditions. Race condition only occur when multiple threads update shared resources. Therefore it is important to know what resources Java threads share when executing.

Java 不共享的資源有：

局部變量 Local varables
局部變量(方法內部變量)存儲在每個線程自己的棧里面，這意味著局部變量不會被多個線程共享。這也意味著所有局部變量都是線程安全的thread safe.
比如：

public void someMethod(){
  long threadSafeInt = 0;
  threadSafeInt++;
}

Java 共享的資源有：

局部對象引用 Local Object References
引用本身是線程安全的，因為他的局部變量。但是引用所?指的對象object并非存儲在線程的局部棧的,而是存儲在共享堆里 shared heap。 每個線程在各自的方法內創建的局部對象，只要不作為返回值返回，其他線程訪問不到，不產生競爭就不會有安全問題

比如如下的例子，因為localObject沒有作為返回值返回，其他的線程獲取不到這個對象的

javapublic void someMethod(){
  LocalObject localObject = new LocalObject();
  localObject.callMethod();
  method2(localObject);
}

public void method2(LocalObject localObject){
  localObject.setValue("value");
}

對象成員變量
對象成員與對象一起存儲在堆里面，對象成員是屬于類的，局部對象引用是屬于方法的，不同的線程訪問或者修改一個類的成員時就會存在競爭.

比如這個例子中，方法add就是線程不安全的(因為build是對象成員變量，多線程都對它同時操作)。

public class NotThreadSafe{
　　StringBuilder builder = new StringBuilder();
　　public add(String text){
　　　　this.builder.append(text);
　　}
}

　　如果兩個線程同時調用同一個 NotThreadSafe 實例的 add() 方法就會引起race condition。比如：

NotThreadSafe sharedInstance = new NotThreadSafe();
new Thread(new MyRunnable(sharedInstance)).start(); // 線程1
new Thread(new MyRunnable(sharedInstance)).start(); // 線程2
public class MyRunnable implements Runnable{
　　NotThreadSafe instance = null;
　　public MyRunnable(NotThreadSafe instance){
　　　　this.instance = instance;
　　}
　　public void run(){
　　　　this.instance.add("some text");
　　}
}

然而如果兩個線程在不同的實例上面同時調用 add() 方法并不會引起靜態條件。下面是稍微修改之后的例子：

new Thread(new MyRunnable(new NotThreadSafe())).start();
new Thread(new MyRunnable(new NotThreadSafe())).start();

　　現在這兩個線程都有自己的 NotThreadSafe 實例，所以它們對 add 方法的調用并不會妨礙對方，這段代碼沒有競態條件。所以即使一個對象不是線程安全的，仍可以找到一個方式來消除競態條件?！?br> 可以使用線程逃逸準則 Thread Control Escape Rule 來判斷是否代碼訪問的資源是線程安全的。

  
如果一個資源在一個線程的控制下被創建、使用和銷毀并且永遠不會逃脫線程的控制，則該資源的使用是線程安全的。

文章版權歸作者所有，未經允許請勿轉載,若此文章存在違規行為，您可以聯系管理員刪除。

轉載請注明本文地址：http://m.specialneedsforspecialkids.com/yun/65302.html

相關文章

  • Java 并發學習筆記（二）

    摘要：請參看前一篇文章并發學習筆記一原子性可見性有序性問題六等待通知機制什么是等待通知機制當線程不滿足某個條件，則進入等待狀態如果線程滿足要求的某個條件后，則通知等待的線程重新執行。經極客時間并發編程實戰專欄內容學習整理 請參看前一篇文章：Java 并發學習筆記（一）——原子性、可見性、有序性問題 六、等待—通知機制 什么是等待通知—機制？當線程不滿足某個條件，則進入等待狀態；如果線程滿足要...

    zgbgx 評論0 收藏0

  • Java 并發學習筆記（一）——原子性、可見性、有序性問題

    摘要：最后，總結一下，導致并發問題的三個源頭分別是原子性一個線程在執行的過程當中不被中斷?？梢娦砸粋€線程修改了共享變量，另一個線程能夠馬上看到，就叫做可見性。 計算機的 CPU、內存、I/O 設備的速度一直存在較大的差異，依次是 CPU > 內存 > I/O 設備，為了權衡這三者的速度差異，主要提出了三種解決辦法： CPU 增加了緩存，均衡和內存的速度差異 發明了進程、線程，分時復用 CP...

    Chao 評論0 收藏0

  • 并發學習筆記 (4)

    摘要：不剝奪條件進程已獲得的資源，在末使用完之前，不能強行剝奪。如果能確保所有的線程都是按照相同的順序獲得鎖，那么死鎖就不會發生。按照順序加鎖是一種有效的死鎖預防機制。這種機制存在一個問題，在中不能對同步塊設置超時時間。 [tutorial site][1] 死鎖 deadlock 死鎖是指兩個或兩個以上的進程在執行過程中，因競爭資源而造成的一種互相等待的現在，若無外力作用，它們都無法推...

    shiguibiao 評論0 收藏0

  • 并發學習筆記 (6)

    摘要：每個通過網絡到達服務器的連接都被包裝成一個任務并且傳遞給線程池。線程池的線程會并發的處理連接上的請求。用線程池控制線程數量，其他線程排隊等候。實現包，線程池頂級接口是但是嚴格意義講并不是一個線程。此線程池支持定時以及周期性執行任務的需求。 tutorial site1tutorial site2 一個問題： 每啟動一個新線程都會有相應的性能開銷(涉及到OS的交互：創建線程，銷毀線程...

    superw 評論0 收藏0

  • Go語言核心36講（Go語言實戰與應用十二）--學習筆記

    摘要：除此之外，把并發安全字典封裝在一個結構體類型中，往往是一個很好的選擇。請看下面的代碼如上所示，我編寫了一個名為的結構體類型，它代表了鍵類型為值類型為的并發安全字典。在這個結構體類型中，只有一個類型的字段。34 | 并發安全字典sync.Map （上）我們今天再來講一個并發安全的高級數據結構：sync.Map。眾所周知，Go 語言自帶的字典類型map并不是并發安全的。前導知識：并發安全字典誕生...

    不知名網友 評論0 收藏0

發表評論

0條評論

最新活動
閱讀需要支付1元查看
<