摘要：線程啟動后系統就自動調用方法。守護線程的使用必須在之前設置，否則會跑出一個異常。你不能把正在運行的常規線程設置為守護線程。在線程中產生的新線程也是的。線程的同步控制使用方法可以釋放對象鎖，使用或可以讓等待的一個或所有線程進入就緒狀態。

一個進程中可以含有多個線程

在操作系統中可以查看線程數

如:在Windows中,在任務管理器,右鍵,選擇列,選中“線程數”

分享CPU(并發的或以時間片的方式)
圖示如下：

共享內存(如多個線程訪問同一對象)

Java從語言級別支持多線程
如:
Object中wait(), notify(),java.lang中的類 Thread

線程啟動后,系統就自動調用run()方法。參考相關書：

所以我們自己調用run是不會產生新的線程的。

通常,run()方法執行一個時間較長的操作

如一個循環

顯示一系列圖片

下載一個文件

class MyThread extends Thread {
    public void run() {
        for(int i=0;i<100;i++) {
            System.out.print (" " + i);
            public void run() { ...}
        }
//生成新線程
Thread thread = new Thread(mytask); thread.start();
    }
}

然而，并不推薦上述方式。參閱了《Introduction to Java Programming》:

This approach is, however, not recommended because it mixes the task and the mechanism of running the task. Separating the task from the thread is a preferred design.

因為Thread中還有其他的方法，這樣可能會混淆了Thread中固有的機制。
Thread類的方法很多，如下：

所以，更好的方式是重新定義一個類來實現抽象類Runnable類，然后采用基于接口的對象注入的方式新建一個Thread的對象。如第二個方法。

class MyTask implements Runnable {
    public void run() { ...}
    }
//生成新線程
Thread thread = new Thread(mytask); thread.start();
}

圖示如下：

使用示例：

public class TestThread4Anonymous {
    public static void main(String args[]) {
        //匿名類
        new Thread(){
            public void run() {
                for(int i=0; i<10; i++)    
                    System.out.println(i);
            }
        }.start();
        //Lambda表達式
        new Thread( ( ) -> { 
            for(int i=0; i<10; i++) 
                System.out.println(" "+ i); 
        } ).start();
    }
}

線程的啟動：thread.start()

線程的結束：常用的方法是設定一個標記變量,結束相應的循環及方法。

暫時阻止線程的執行，比如在線程中用暫停方法：thread.sleep( 1000 );

調用設定線程的優先級setPriority( int priority)方法，默認有以下三種
MIN_PRIORITY,MAX_PRIORITY,NORM_PRIORITY

線程有兩種:

一類是普通線程(非Daemon線程)
在Java程序中,若還有非Demon線程,則整個程序就不會結束

一類是Daemon線程(守護線程,后臺線程)
使用setDaemon(true);如果普通線程結束了,則后臺線程自動終止。

注:垃圾回收線程是后臺線程

public class daemon {
    public static void main(String args[]) {
        //創建子線程
        Runnable t = new MyThread2();
        Thread thread = new Thread(t);
        thread.setDaemon(true);
        thread.start();

        System.out.println( "主線程開始運行." );
        try{
            Thread.sleep(500);
        }
        catch(InterruptedException ex){}
        System.out.println("主線程結束,子線程由于設置為守護線程,所以也應該提前結束.");
    }
}

class MyThread2 implements Runnable {
    public void run() {
        for(int i=0; i<10; i++ ){
            System.out.println(  "子線程應該循環10次,當前的第"+i+"次");
            try{ Thread.sleep(100); }
            catch(InterruptedException ex){}
        }
    }
}

輸出結果：

主線程開始運行.
子線程應該循環10次,當前的第0次
子線程應該循環10次,當前的第1次
子線程應該循環10次,當前的第2次
子線程應該循環10次,當前的第3次
子線程應該循環10次,當前的第4次
主線程結束,子線程由于設置為守護線程,所以也應該提前結束.

可以從上面看出，守護線程即使在運行中，也應該隨著主線程的結束而提前結束。

thread.setDaemon(true)必須在thread.start()之前設置，否則會跑出一個IllegalThreadStateException異常。你不能把正在運行的常規線程設置為守護線程。

在Daemon線程中產生的新線程也是Daemon的。

守護線程應該永遠不去訪問固有資源，如文件、數據庫，因為它會在任何時候甚至在一個操作的中間發生中斷。

為什么線程需要同步：
同時運行的線程需要共享數據、就必須考慮其它線程的狀態與行為,這時就需要實現同步。

Java引入了對象互斥鎖的概念,來保證共享數據操作的完整性。
每個對象都對應于一個monitor(監視器),它上面 一個稱為“互斥鎖(lock, mutex)”的標記,這個標記用來保證在任一時刻,只能有一個線程訪問該對象。
關鍵字synchronized用來與對象的互斥鎖聯系。

synchronized的用法(2種)

對代碼片斷:

synchronized(對象){ 。。。。}

對某個方法:

synchronized放在方法聲明中，如
public synchronized void push(char c ){ 。。。。}

以上相當于對synchronized(this), 表示整個方法為同步方法。

使用wait()方法可以釋放對象鎖，使用notify()或notifyAll()可以讓等待的一個或所有線程進入就緒狀態。
Java里面可以將wait()和notify()放在synchronized里面,是因為Java是這樣處理的:

在synchronized代碼被執行期間,線程調用對象的wait()方法,會釋放對象鎖標志,然后進入等待狀態,然后由其它線程調用notify()或者notifyAll()方法通知正在等待的線程。

JDK1.5中增加了更多的類,以便更靈活地使用鎖機制
Lock接口、ReentrantLock類，如下：

ReadWriteLock接口、ReentrantReadWriteLock類
如.writeLock(),.lock(), .readLock(),.unlock()，這些方法。

java.util.concurrent包中增加了一些方便的類

常用于很少寫入而讀取頻繁的對象

CopyOnWriteArrayList、 CopyOnWriteArraySet

ConcurrentHashMap

putIfAbsent(), remove(), replace()

ArrayBlockingQueue

ExecutorService 接口、ThreadPoolExecutor 類

Executors 工具類
他們同樣位于Concurrent接口的實現下面，如下：

ExecutorService pool = Executors.newCachedThreadPool();

使用其execute( Runnable r)方法

import java.util.concurrent.*;
/** 創建線程池示例
   */
public class ExecutorDemo {
  public static void main(String[] args) {
    // 創建線程池對象
    ExecutorService  executor = Executors.newCachedThreadPool();
    
    // 提交任務到線程池
    executor.execute(new PrintChar("a", 4));
    executor.execute(new PrintChar("b", 2));
    executor.execute(new PrintNum(2));
    //關閉線程池
    executor.shutdown();
   }
}
class PrintChar implements Runnable {
  private char charToPrint; // The character to print
  private int times; // The times to repeat

  /** 給定打印次數，打印特定字符
   */
  public PrintChar(char c, int t) {
    charToPrint = c;
    times = t;
  }

輸出結果

aaaabb 1 2

這里是指Java8新增的函數式思想，并不是具體的文件輸入輸出流。使得某些編程語句更加流暢的表達。
比如，對數組進行流化：

Arrays.stream(a)
    .filter( i -> i>20 )
    .map(i->i*i)
    .sorted()
    .distinct()
    .limit(10)
    .max();

流操作分成兩類:

中間的 -中間的操作保持流打開狀態,并允許后續的操作。

如: filter sorted limit map

末端的 - 末端的操作必須是對流的最終操作。

如: max min count forEach findAny

從某個源頭獲得一個流。

執行一個或更多的中間的操作。

執行一個末端的操作。

對于數組

Arrays.stream(ary)

對于collection (包括List)

用 list.stream()

對于Map，沒有流,但提供了類似的方法

如map.putIfAbsent

map.computeIfPresent

map.merge

import java.util.*;
class UseStream
{
    public static void main(String[] args)
    {
        List a = Arrays.asList(1,2,5,7,3);
        System.out.println(
                a.stream()
                        .mapToInt(i->(int)i)
                        .filter( i -> i>2 )
                        .map( i -> i*i )
                        .sorted()
                        .distinct()
                        .limit(10)
                        .max()
        );
    }
}

運行結果：

OptionalInt[49]

只需將上面代碼的.stream()換成 .parallelStream()。

其他都不變,就可以實現并行計算

可以說，stream就是為并行運算而生的，它封裝的并行計算的大量內部細節。