1.線程組的概述和使用
Java中使用ThreadGroup來表示線程組，它可以對一批線程進行分類管理，Java允許程序直接對線程組進行控制。
(1)默認情況下，所有線程都屬於線程組
public final ThreadGroup getThreadGroup() //通過線程對象獲取它所屬於的組
public final String getName() //通過線程組對象獲取它組的名字
(2)自己給線程設置分組
1)ThreadGroup(String name) 創建線程組對象並給其賦值名字
2)創建線程對象
3)Thread(ThreadGroup?group,Runnable?target,String?name)
4)設置整組的優先級或者守護線程
2.線程的五種狀態
(1)新建：創建線程對象
(2)就緒：線程對象已啓動，但是還沒有獲取到cpu的執行權
(3)運行：獲取到了cpu的執行權
(4)阻塞：沒有cpu的執行權，回到就緒
(5)死亡：代碼運行完畢，線程消亡
3.線程池的概述和使用
程序啓動一個新線程成本使比較高的，因爲涉及到與操作系統進行交互。使用線程池可以很好的提高性能，尤其是當程序 中要創建大量生存期很短的線程時，更應該考慮使用線程池。 線程池裏的每一個線程代碼結束後，並不會死亡，而是再回 到線程池中成爲空閒狀態，等待下一個對象來使用。
(1)JDK5增加了一個Executors工廠類來產生線程池，有以下幾個方法
public static ExecutorService newFixedThreadPool(int nThreads),放n條線程
public static ExecutorService newSingleThreadExecutor(int nThreads)
這些方法的返回值是ExecutorService對象，該對象表示一個線程池，可以執行Runnable對象或者Callable對象代表的線 程，它提供瞭如下的方法
Future<?> submit(Runnable task)
<T> Future<t> submit(Callable<T> task)
(2)使用步驟
1)創建線程池對象
2)創建Runnable實例
3)提交Runnable實例
4)關閉線程池
4.簡單工廠設計模式的概述和使用
又叫靜態工廠方法模式，它定義了一個具體的工廠類負責創建一些類的實例
優點：客戶端不需要在負責對象的創建，從而明確了各個類的指責
缺點：他負責所有對象的創建，如果有新的對象增加，或者某些對象的創建方式不同，就需要不斷地修改工廠類，不利 於後期地維護
5.工廠方法模式的概述和使用
工廠方法模式中抽象工廠類負責定義創建對象的接口，具體對象的創建工作由繼承抽象工廠的具體類實現
優點：客戶端不要在負責對象的創建，從而明確了各個類的職責，如果有新的對象增加，只需要增加一個具體的類和具 體的工廠類即可，不影響已有代碼，後期維護容易，增強系統的擴展性
缺點：需要額外的編寫代碼，增加了工作量
package pra_22;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
public class J_41 {
/**
* @param args
* @throws ExecutionException
* @throws InterruptedException
*/
public static void main(String[] args) throws InterruptedException, ExecutionException {
//1.線程組的使用，能使一組線程的狀態發生改變
MyRun mr=new MyRun();
Thread t1=new Thread(mr,"aa");
Thread t2=new Thread(mr,"bb");
ThreadGroup tg=t1.getThreadGroup();
ThreadGroup tg2=t2.getThreadGroup();
System.out.println(tg.getName()); //main
System.out.println(tg2.getName()); //main
ThreadGroup tg3=new ThreadGroup("new"); //創建新的線程組
MyRun mr2=new MyRun(); //創建Runnable的子類對象
Thread t3=new Thread(tg3,mr2,"cc"); //將線程t3放在組中
Thread t4=new Thread(tg3,mr2,"dd");
System.out.println(t3.getThreadGroup().getName()); //獲取組名
System.out.println(t4.getThreadGroup().getName());
//2.線程池的使用
/*
ExecutorService esp=Executors.newFixedThreadPool(2); //創建線程池
esp.submit(new MyRun()); //將線程放進池子裏並執行
esp.submit(new MyRun());
esp.shutdown(); //關閉線程池
*/
//3.多線程程序實現的方式(使用線程池的方法)
ExecutorService esp2=Executors.newFixedThreadPool(2);
Future<Integer> f1=esp2.submit(new MyC(10));
Future<Integer> f2=esp2.submit(new MyC(100));
System.out.println(f1.get());
System.out.println(f2.get());
esp2.shutdown();
//4.簡單工廠設計模式
Nurse N=(Nurse)PeopleFac.Createp("nurse");
N.work();
Stu s=(Stu)PeopleFac.Createp("stu");
s.work();
//5.工廠方法設計模式
StuFac sf=new StuFac();
Stu s2=(Stu)sf.createP();
NurseFac nf=new NurseFac();
Nurse n2=(Nurse) nf.createP();
s2.work();
n2.work();
}
}
//線程組的使用
class MyRun implements Runnable{
@Override
public void run() {
for(int i=0;i<1000;i++){
System.out.println(Thread.currentThread().getName()+":"+i);
}
}
}
//簡單工廠設計模式
class MyC implements Callable<Integer>{
private int num;
public MyC(int num){
this.num=num;
}
@Override
public Integer call() throws Exception {
int sum=0;
for(int i=1;i<num;i++){
sum+=i;
}
return sum;
}
}
abstract class People{
public abstract void work();
}
class Stu extends People{
@Override
public void work() {
System.out.println("School");
}
}
class Nurse extends People{
@Override
public void work() {
System.out.println("hospital");
}
}
class PeopleFac{
/* 這樣子會定義很多方法，複用性差
public static Stu createS(){
return new Stu();
}
public static Nurse createN(){
return new Nurse();
}
*/
public static People Createp(String name){
if("stu".equals(name)){
return new Stu();
}else if("nurse".equals(name)){
return new Nurse();
}else{
return null;
}
}
}
//工廠方法設計模式
interface Fac{
public People createP();
}
class StuFac implements Fac{
@Override
public People createP() {
return new Stu();
}
}
class NurseFac implements Fac{
@Override
public People createP() {
return new Nurse();
}
}