Java的简单理解(25)---线程(Thread)

Java

1. Runnable创建线程

使用Runnable创建线程

1. 类实现Runnable接口 + 重写run()方法 ---> 真实角色类
2. 启动多线程，使用静态代理

public class Progremmer implements Runnable {

    @Override
    public void run() {
        for (int i = 0; i < 1000; i++) {
            Log.d("WM","一边敲着代码");
        }
    }
}

// 使用静态代理模式开启线程

// 1. 创建真实角色类
Progremmer progremmer = new Progremmer();

// 2. 创建代理角色 + 真实角色引用
Thread thread = new Thread(progremmer);

// 3. start(),启动线程
thread.start();

for (int i = 0; i < 1000; i++) {
    Log.d("WM","一边吃着火锅");
}

2. 通过Callable接口实现多线程

1. 创建Callable实现类 + 重写call方法

public class Race implements Callable<Integer> {

    private String name;
    private long time;
    private boolean flag = true;
    private int step = 0;

    public Race() {

    }

    public Race(String name) {
        this.name = name;
    }

    public Race(String name, long time) {
        this.name = name;
        this.time = time;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public long getTime() {
        return time;
    }

    public void setTime(long time) {
        this.time = time;
    }

    public boolean isFlag() {
        return flag;
    }

    public void setFlag(boolean flag) {
        this.flag = flag;
    }

    public int getStep() {
        return step;
    }

    public void setStep(int step) {
        this.step = step;
    }
    
    @Override
    public Integer call() throws Exception {
        while (flag) {
            Thread.sleep(time); // 延时
            step++;
        }
        return step;
    }
}

2. 借助执行调度服务ExecutorService，获取Future对象

// 创建线程
ExecutorService ser = Executors.newFixedThreadPool(2);

Race race1 = new Race("乌龟", 1000);
Race race2 = new Race("兔子", 500);
// 获取值
Future<Integer> result1 = ser.submit(race1);
Future<Integer> result2 = ser.submit(race2);

3. 获取值result.get()

int num1 = result1.get();
int num2 = result2.get();

4. 停止服务

// 停止服务
ser.shutdownNow();