JAVA多线程

多线程

Java.Thread

process (进程) 一个进程中至少有一个线程；

第一种方式，继承Thread类；

继承Thread类，重写run方法，创建子类对象，调用父类start方法开始执行；

第二种方式，实现Runnable接口

Thread类也是实现了Runnable接口；

定义MyRunnable类实现Runnable接口；

实现run方法；

创建线程对象（Thread），调用start（）方法启动线程；

​ MyRunnable myrunnable = new MyRunnable(143);

​ new Thread（myrunnable）.start（）； //代理

小结

继承Thread类

​ 子类继承后具备多线程能力

​ 启动线程：子类对象.start（）；

​ 不建议使用：避免OOP单继承局限性；

实现Runnable接口

​ 实现接口Runnable具备多线程能力；

​ 启动线程：传入目标对象参数到Thread对象.start（）；

​ 推荐使用：避免单继承局限性，灵活方便，方便同一个对象被多个线程使用；

第三种方式，实现Callable接口

实现Callable接口，需要返回值类型；

重写call方法，需要抛出异常；

创建目标对象；

创建执行服务:ExecutorService ser = Executors.newFixedThreadPool(1);//1个池子

提交执行：Futureresult1=ser.submit(t1);

获取结果：boolean r1 = result1.get();

关闭服务：ser.shutdownNow();

小结

Callable的好处

​ 可以定义返回值

​ 可以抛出异常

静态代理

真实对象（目标对象）和代理对象都要实现同一接口，真实角色传入参数到代理对象中；

public class StaticProxy {
    public static void main(String[] args) {
        WeddingCompany weddingCompany = new WeddingCompany(new You());
        weddingCompany.happyMarry();
    }
}

interface Marry{
    //人间四大喜事
    // 久旱逢甘霖   他乡遇故知    洞房花烛夜     金榜题名时
    void happyMarry();
}
//真实角色，你去结婚
class You implements Marry{
    @Override
    public void happyMarry() {
        System.out.println("我想和你结婚");
    }
}
//代理角色，帮助你结婚
class WeddingCompany implements Marry{
    private Marry target;
	//代理角色->真实角色
    public WeddingCompany(Marry target) {
        this.target = target;
    }

    public WeddingCompany() {

    }

    @Override
    public void happyMarry() {
        before();
        this.target.happyMarry();//真实对象
        after();
    }

    private void after() {
        System.out.println("结婚之后收尾款");
    }

    private void before(){
        System.out.println("结婚之前布置现场");
    }
}

代理对象要代理真实角色；

好处，代理对象可以做很多真实对象做不了的事情；

​ 真实对象专注做自己的事情；