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();
}
}