Java基礎——Java重點基礎之多線程（二）

一，單例設計模式

單例設計模式：保證類在內存中只有一個對象。
如何保證類在內存中只有一個對象呢？
- (1)控制類的創建，不讓其他類來創建本類的對象。private
- (2)在本類中定義一個本類的對象。Singleton s;
- (3)提供公共的訪問方式。 public static Singleton getInstance(){return s}

單例寫法兩種：

(1)餓漢式開發用這種方式。

//餓漢式
class Singleton {
    //1,私有構造函數
    private Singleton(){}
    //2,創建本類對象
    private static Singleton s = new Singleton();
    //3,對外提供公共的訪問方法
    public static Singleton getInstance() {
        return s;
    }

    public static void print() {
        System.out.println("11111111111");
    }
}

(2)懶漢式面試寫這種方式。多線程的問題？

//懶漢式,單例的延遲加載模式
class Singleton {
    //1,私有構造函數
    private Singleton(){}
    //2,聲明一個本類的引用
    private static Singleton s;
    //3,對外提供公共的訪問方法
    public static Singleton getInstance() {
        if(s == null)
            //線程1,線程2
            s = new Singleton();
        return s;
    }

    public static void print() {
        System.out.println("11111111111");
    }
}

(3)第三種格式

class Singleton {
    private Singleton() {}

    public static final Singleton s = new Singleton();//final是最終的意思,被final修飾的變量不可以被更改
}

二，Runtime類

Runtime類是一個單例類

Runtime r = Runtime.getRuntime();
//r.exec("shutdown -s -t 300");     //300秒後關機
r.exec("shutdown -a");              //取消關機

三，Timer

Timer類:計時器

public class Demo5_Timer {
        /**
         * @param args
         * 計時器
         * @throws InterruptedException 
         */
        public static void main(String[] args) throws InterruptedException {
            Timer t = new Timer();
            t.schedule(new MyTimerTask(), new Date(114,9,15,10,54,20),3000);

            while(true) {
                System.out.println(new Date());
                Thread.sleep(1000);
            }
        }
    }
    class MyTimerTask extends TimerTask {
        @Override
        public void run() {
            System.out.println("起牀背英語單詞");
        }

    }

四，兩個線程間的通信

1.什麼時候需要通信
- 多個線程併發執行時, 在默認情況下CPU是隨機切換線程的
- 如果我們希望他們有規律的執行, 就可以使用通信, 例如每個線程執行一次打印
2.怎麼通信
- 如果希望線程等待, 就調用wait()
- 如果希望喚醒等待的線程, 就調用notify();
- 這兩個方法必須在同步代碼中執行, 並且使用同步鎖對象來調用

五，三個或三個以上間的線程通信

多個線程通信的問題
- notify()方法是隨機喚醒一個線程
- notifyAll()方法是喚醒所有線程
- JDK5之前無法喚醒指定的一個線程
- 如果多個線程之間通信, 需要使用notifyAll()通知所有線程, 用while來反覆判斷條件

六，JDK1.5的新特性互斥鎖

1.同步
- 使用ReentrantLock類的lock()和unlock()方法進行同步
2.通信
- 使用ReentrantLock類的newCondition()方法可以獲取Condition對象
- 需要等待的時候使用Condition的await()方法, 喚醒的時候用signal()方法
- 不同的線程使用不同的Condition, 這樣就能區分喚醒的時候找哪個線程了

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;

public class Demo3_ReentrantLock {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		final Printer3 p = new Printer3();
		
		new Thread() {
			public void run() {
				while(true) {
					try {
						p.print1();
					} catch (InterruptedException e) {
						
						e.printStackTrace();
					}
				}
			}
		}.start();
		
		new Thread() {
			public void run() {
				while(true) {
					try {
						p.print2();
					} catch (InterruptedException e) {
						
						e.printStackTrace();
					}
				}
			}
		}.start();
		
		new Thread() {
			public void run() {
				while(true) {
					try {
						p.print3();
					} catch (InterruptedException e) {
						
						e.printStackTrace();
					}
				}
			}
		}.start();
	}

}

class Printer3 {
	private ReentrantLock r = new ReentrantLock();
	private Condition c1 = r.newCondition();
	private Condition c2 = r.newCondition();
	private Condition c3 = r.newCondition();
	
	private int flag = 1;
	public void print1() throws InterruptedException {							
		r.lock();								//獲取鎖
			if(flag != 1) {
				c1.await();
			}
			System.out.print("黑");
			System.out.print("馬");
			System.out.print("程");
			System.out.print("序");
			System.out.print("員");
			System.out.print("\r\n");
			flag = 2;
			//this.notify();						//隨機喚醒單個等待的線程
			c2.signal();
		r.unlock();								//釋放鎖
	}
	
	public void print2() throws InterruptedException {
		r.lock();
			if(flag != 2) {
				c2.await();
			}
			System.out.print("傳");
			System.out.print("智");
			System.out.print("播");
			System.out.print("客");
			System.out.print("\r\n");
			flag = 3;
			//this.notify();
			c3.signal();
		r.unlock();
	}
	
	public void print3() throws InterruptedException {
		r.lock();
			if(flag != 3) {
				c3.await();
			}
			System.out.print("i");
			System.out.print("t");
			System.out.print("h");
			System.out.print("e");
			System.out.print("i");
			System.out.print("m");
			System.out.print("a");
			System.out.print("\r\n");
			flag = 1;
			c1.signal();
		r.unlock();
	}
}

七，線程組的概述和使用

A:線程組概述

Java中使用ThreadGroup來表示線程組，它可以對一批線程進行分類管理，Java允許程序直接對線程組進行控制。
默認情況下，所有的線程都屬於主線程組。
- public final ThreadGroup getThreadGroup()//通過線程對象獲取他所屬於的組
- public final String getName()//通過線程組對象獲取他組的名字
我們也可以給線程設置分組
- 1,ThreadGroup(String name) 創建線程組對象並給其賦值名字
- 2,創建線程對象
- 3,Thread(ThreadGroup?group, Runnable?target, String?name)
- 4,設置整組的優先級或者守護線程
B:案例演示
- 線程組的使用,默認是主線程組

MyRunnable mr = new MyRunnable();
Thread t1 = new Thread(mr, "張三");
Thread t2 = new Thread(mr, "李四");
//獲取線程組
// 線程類裏面的方法：public final ThreadGroup getThreadGroup()
ThreadGroup tg1 = t1.getThreadGroup();
ThreadGroup tg2 = t2.getThreadGroup();
// 線程組裏面的方法：public final String getName()
String name1 = tg1.getName();
String name2 = tg2.getName();
System.out.println(name1);
System.out.println(name2);
// 通過結果我們知道了：線程默認情況下屬於main線程組
// 通過下面的測試，你應該能夠看到，默任情況下，所有的線程都屬於同一個組
System.out.println(Thread.currentThread().getThreadGroup().getName());

自己設定線程組

// ThreadGroup(String name)
ThreadGroup tg = new ThreadGroup("這是一個新的組");

MyRunnable mr = new MyRunnable();
// Thread(ThreadGroup group, Runnable target, String name)
Thread t1 = new Thread(tg, mr, "張三");
Thread t2 = new Thread(tg, mr, "李四");

System.out.println(t1.getThreadGroup().getName());
System.out.println(t2.getThreadGroup().getName());

//通過組名稱設置後臺線程，表示該組的線程都是後臺線程
tg.setDaemon(true);

八，線程的五種狀態

看圖說話
新建,就緒,運行,阻塞,死亡

九，線程池的概述和使用

A:線程池概述
- 程序啓動一個新線程成本是比較高的，因爲它涉及到要與操作系統進行交互。而使用線程池可以很好的提高性能，尤其是當程序中要創建大量生存期很短的線程時，更應該考慮使用線程池。線程池裏的每一個線程代碼結束後，並不會死亡，而是再次回到線程池中成爲空閒狀態，等待下一個對象來使用。在JDK5之前，我們必須手動實現自己的線程池，從JDK5開始，Java內置支持線程池
B:內置線程池的使用概述
- JDK5新增了一個Executors工廠類來產生線程池，有如下幾個方法
  - public static ExecutorService newFixedThreadPool(int nThreads)
  - public static ExecutorService newSingleThreadExecutor()
  - 這些方法的返回值是ExecutorService對象，該對象表示一個線程池，可以執行Runnable對象或者Callable對象代表的線程。它提供瞭如下方法
  - Future<?> submit(Runnable task)
  - Future submit(Callable task)
- 使用步驟：
  - 創建線程池對象
  - 創建Runnable實例
  - 提交Runnable實例
  - 關閉線程池
- C:案例演示
  - 提交的是Runnable
  - ```
  // public static ExecutorService newFixedThreadPool(int nThreads)
  ExecutorService pool = Executors.newFixedThreadPool(2);
  
  // 可以執行Runnable對象或者Callable對象代表的線程
  pool.submit(new MyRunnable());
  pool.submit(new MyRunnable());
  
  //結束線程池
  pool.shutdown();
```

十，多線程程序實現的方式3

提交的是Callable

// 創建線程池對象
ExecutorService pool = Executors.newFixedThreadPool(2);

// 可以執行Runnable對象或者Callable對象代表的線程
Future<Integer> f1 = pool.submit(new MyCallable(100));
Future<Integer> f2 = pool.submit(new MyCallable(200));

// V get()
Integer i1 = f1.get();
Integer i2 = f2.get();

System.out.println(i1);
System.out.println(i2);

// 結束
pool.shutdown();

public class MyCallable implements Callable<Integer> {

    private int number;

    public MyCallable(int number) {
        this.number = number;
    }

    @Override
    public Integer call() throws Exception {
        int sum = 0;
        for (int x = 1; x <= number; x++) {
            sum += x;
        }
        return sum;
    }

}

多線程程序實現的方式3的好處和弊端
- 好處：
  - 可以有返回值
  - 可以拋出異常
- 弊端：
  - 代碼比較複雜，所以一般不用

十一，簡單工廠模式概述和使用

A:簡單工廠模式概述
- 又叫靜態工廠方法模式，它定義一個具體的工廠類負責創建一些類的實例
B:優點
- 客戶端不需要在負責對象的創建，從而明確了各個類的職責
C:缺點
- 這個靜態工廠類負責所有對象的創建，如果有新的對象增加，或者某些對象的創建方式不同，就需要不斷的修改工廠類，不利於後期的維護
D:案例演示
- 動物抽象類：public abstract Animal { public abstract void eat(); }
- 具體狗類：public class Dog extends Animal {}
- 具體貓類：public class Cat extends Animal {}
- 開始，在測試類中每個具體的內容自己創建對象，但是，創建對象的工作如果比較麻煩，就需要有人專門做這個事情，所以就知道了一個專門的類來創建對象。

public class AnimalFactory {
    private AnimalFactory(){}

    //public static Dog createDog() {return new Dog();}
    //public static Cat createCat() {return new Cat();}

    //改進
    public static Animal createAnimal(String animalName) {
        if(“dog”.equals(animalName)) {}
        else if(“cat”.equals(animale)) {

        }else {
            return null;
        }
    }
}

十二，工廠方法模式的概述和使用

A:工廠方法模式概述
- 工廠方法模式中抽象工廠類負責定義創建對象的接口，具體對象的創建工作由繼承抽象工廠的具體類實現。
B:優點
- 客戶端不需要在負責對象的創建，從而明確了各個類的職責，如果有新的對象增加，只需要增加一個具體的類和具體的工廠類即可，不影響已有的代碼，後期維護容易，增強了系統的擴展性
C:缺點
- 需要額外的編寫代碼，增加了工作量
D:案例演示

動物抽象類：public abstract Animal { public abstract void eat(); }
工廠接口：public interface Factory {public abstract Animal createAnimal();}
具體狗類：public class Dog extends Animal {}
具體貓類：public class Cat extends Animal {}
開始，在測試類中每個具體的內容自己創建對象，但是，創建對象的工作如果比較麻煩，就需要有人專門做這個事情，所以就知道了一個專門的類來創建對象。發現每次修改代碼太麻煩，用工廠方法改進，針對每一個具體的實現提供一個具體工廠。
狗工廠：public class DogFactory implements Factory {
    public Animal createAnimal() {…}
        }
貓工廠：public class CatFactory implements Factory {
    public Animal createAnimal() {…}
        }

十三，GUI(佈局管理器)

FlowLayout（流式佈局管理器）
- 從左到右的順序排列。
- Panel默認的佈局管理器。
BorderLayout（邊界佈局管理器）
- 東，南，西，北，中
- Frame默認的佈局管理器。
GridLayout（網格佈局管理器）
- 規則的矩陣
CardLayout（卡片佈局管理器）
- 選項卡
GridBagLayout（網格包佈局管理器）
- 非規則的矩陣

十四，GUI(窗體監聽)

Frame f = new Frame("我的窗體");
//事件源是窗體,把監聽器註冊到事件源上
//事件對象傳遞給監聽器
f.addWindowListener(new WindowAdapter() {
          public void windowClosing(WindowEvent e) {
                     //退出虛擬機,關閉窗口
        System.exit(0);
    }
});

十五，GUI(鼠標監聽)

十六，GUI(鍵盤監聽和鍵盤事件)

十七，GUI(動作監聽)

十八，設計模式(適配器設計模式)(掌握)

a.什麼是適配器
- 在使用監聽器的時候, 需要定義一個類事件監聽器接口.
- 通常接口中有多個方法, 而程序中不一定所有的都用到, 但又必須重寫, 這很繁瑣.
- 適配器簡化了這些操作, 我們定義監聽器時只要繼承適配器, 然後重寫需要的方法即可.
b.適配器原理
- 適配器就是一個類, 實現了監聽器接口, 所有抽象方法都重寫了, 但是方法全是空的.
- 適配器類需要定義成抽象的,因爲創建該類對象,調用空方法是沒有意義的
- 目的就是爲了簡化程序員的操作, 定義監聽器時繼承適配器, 只重寫需要的方法就可以了.

十九，GUI(需要知道的)