死鎖現象:DeadLock，當多線程訪問互斥的網絡資源時（共享資源，但是訪問順序相反），由於線程安全問題而加的多層同步，導致程序鎖死現象，稱為死鎖。

解決死鎖的方法：盡量減少加的同步的次數。

死鎖代碼示例：

 1 package DemoList;
 2 
 3 public class Demo1 {
 4 
 5     public static void main(String[] args) {
 6         ExtendsThread et1=new ExtendsThread();
 7         ExtendsThread et2=new
 
 ExtendsThread();
 8         et1.flag=true;
 9         et2.flag=false;
10         et1.start();
11         et2.start();
12     }
13 }
14 class ExtendsThread extends Thread{
15     static Object obj=new Object();
16     static Object obj2=new Object();
17     
18     boolean flag;
19     @Override
 
20     public void run() {
21         if(flag) {
22             synchronized (obj) {
23                 System.out.println("true obj");    
24             synchronized (obj2) {
25                 System.out.println("true obj2");
26             }
27         }
28         }else {
29             synchronized
 
 (obj2) {
30                 System.out.println("false obj2");
31             synchronized (obj) {
32                 System.out.println("false obj");
33             }
34             }
35         }
36     }
37 }

正常的執行結果為：

但是偶爾會有非正常的執行結果：

之所以會出現上面的這種情況，是因為計算機的執行速度快，et1在拿到obj1並且拿到obj2之後，et2才開始拿，這時候et1已經將obj1和obj2釋放，所以可以四個結果都拿到。

那麽要解決這個問題，可以在第一層鎖後邊加Thread.sleep（）方法，這樣確保了et1拿到obj1的時候，et2拿到obj2了，所以不會出現上述情況

代碼示例：

 1 package DemoList;
 2 
 3 public class Demo1 {
 4 
 5     public static void main(String[] args) {
 6         ExtendsThread et1=new ExtendsThread();
 7         ExtendsThread et2=new ExtendsThread();
 8         et1.flag=true;
 9         et2.flag=false;
10         et1.start();
11         et2.start();
12     }
13 }
14 class ExtendsThread extends Thread{
15     static Object obj=new Object();
16     static Object obj2=new Object();
17     
18     boolean flag;
19     @Override
20     public void run() {
21         if(flag) {
22             synchronized (obj) {
23                 System.out.println("true obj");    
24                 try {
25                     Thread.sleep(100);   //在這裏加上Thread.sleep()方法
26                 } catch (InterruptedException e) {
27                     // TODO Auto-generated catch block
28                     e.printStackTrace();
29                 }
30             synchronized (obj2) {
31                 System.out.println("true obj2");
32             }
33         }
34         }else {
35             synchronized (obj2) {
36                 System.out.println("false obj2");
37             synchronized (obj) {
38                 System.out.println("false obj");
39             }
40             }
41         }
42     }
43 }

線程池：

存放多個線程的池子：

線程池產生的原因：降低內存的開銷

使用線程，需要創建線程對象，並且使用完，要銷毀線程對象，頻繁的創建和銷毀線程，會加大內存的開銷。

一個進程，會使用多個線程

線程池涉及到的類：

Executors：創建線程池的工具類

常用方法： newFixedThreadPool（int nThread） 創建固定個數線程的線程池

ExecutorService 管理線程池的類

submit（Runnable task）獲取線程的方法

shoutdown（） 關閉

代碼示例：

 1 package DemoList;
 2 
 3 import java.util.concurrent.ExecutorService;
 4 import java.util.concurrent.Executors;
 5 
 6 public class Demo9 {
 7 
 8     public static void main(String[] args) {
 9         ExecutorService es=Executors.newFixedThreadPool(3);
10         es.submit(new ImplementsRunnable2());
11         es.submit(new ImplementsRunnable2());
12         es.submit(new ImplementsRunnable2());
13     }
14 }
15 class ImplementsRunnable2 implements Runnable{
16 
17     @Override
18     public void run() {
19         System.out.println(Thread.currentThread().getName());
20     }
21 }

執行結果：

線程池和線程組的區別：線程池就是將所有的線程都放在裏面，而線程組是將相同的線程放在一起，比如main線程組裏都是main方法裏的線程，自定義線程組裏都是自定義的線程

如果需要使用的線程數大於線程組裏的線程數，那麽就會有線程等待，就好像水房裏有十個水龍頭，但是有二十位同學一起去打水，沒搶到水龍頭的同學只能等別人打完水了再去打水。

JAVA中 死鎖&線程池