多线程的基本使用

一、进程与线程

1、进程：程序的一次执行过程，是系统资源分配的单位。
2、线程：进程中包含多个线程，是cpu调度和执行的单位。

二、实现多线程

1、继承Thread

package createThread;

//继承thread类，重写run方法，调用start
public class ExtendsThread extends Thread {
   
    @Override
    public void run() {
   
        for (int i = 0; i < 20; i++) {
   
            System.out.println(Thread.currentThread().getName()+"----"+i);
        }
    }

    public static void main(String[] args) {
   
        ExtendsThread t1= new ExtendsThread();
        t1.start();
        System.out.println("我在看书");
    }
}

2、实现Runnable接口

package createThread;

//实现Runnable接口，重写Run方法，丢入实现类，调用start
public class ImplementsRunnable implements Runnable {
   

    @Override
    public void run() {
   
        for (int i = 0; i < 20; i++) {
   
            System.out.println(Thread.currentThread().getName()+"----"+i);
        }
    }

    //thread实现了Runnable接口
    public static void main(String[] args) {
   
        ImplementsRunnable t1 = new ImplementsRunnable();
        new Thread(t1).start();
        for (int i=0;i<20;i++){
   
            System.out.println("看书的"+i+"秒");
        }
    }
}

由于java只能单继承，因此实现Runnable接口的方式来实现多线程是更为灵活的。
3、简单案例：龟兔赛跑

package demo;

//龟兔赛跑
public class Race implements Runnable {
   

    private static String winner;

    @Override
    public void run() {
   
        for (int i = 0; i <= 100; i++) {
   
            boolean flag = gameOver(i);
            if (flag) break;
            System.out.println(Thread.currentThread().getName()+"跑了"+i+"米");
        }
    }

    private boolean gameOver(int steps){
   
        if(winner!=null){
   
            return true;
        }else if (steps==100){
   
            winner = Thread.currentThread().getName();
            System.out.println(winner+"是冠军！");
            return true;
        }else{
   
            return false;
        }
    }

    public static void main(String[] args) {
   
        Race race = new Race();
        new Thread(race,"兔子").start();
        new Thread(race,"乌龟").start();
    }
}

3、实现Callable接口

package createThread;

import java.util.concurrent.*;

public class ImplementsCallable implements Callable<Boolean> {
   
    @Override
    public Boolean call() throws Exception {
   
        for (int i = 0; i < 100; i++) {
   
            System.out.println("第"+i+"-->"+Thread.currentThread().getName());
        }
        return true;
    }

    public static void main(String[] args) {
   
        ImplementsCallable t1 = new ImplementsCallable();
        ImplementsCallable t2 = new ImplementsCallable();
        ImplementsCallable t3 = new ImplementsCallable();

        //创建执行服务
        ExecutorService ser = Executors.newFixedThreadPool(3);

        //提交执行
        Future<Boolean> r1 = ser.submit(t1);
        Future<Boolean> r2 = ser.submit(t2);
        Future<Boolean> r3 = ser.submit(t3);

        //获取结果
        try {
   
            boolean res1 = r1.get();
            boolean res2 = r2.get();
            boolean res3 = r3.get();
        } catch (InterruptedException e) {
   
            e.printStackTrace();
        } catch (ExecutionException e) {
   
            e.printStackTrace();
        }

        //关闭服务
        ser.shutdown();
    }
}

三、静态代理模式

真实对象和代理对象都实现同一个接口，真实对象交由代理对象来执行；
Thread代理了实现Runnable接口的对象调用start()方法。

package demo;

public class StaticProxy {
   
    public static void main(String[] args) {
   
        Company company = new Company(new You());
        company.HappyMarry();
    }
}

interface Marry{
   
    public void HappyMarry(