线程概念及实现方式

多任务是指用户可以在同一时间内运行多个应用程序，每一个应用程序被称作一个任务。

多线程是指计算机可以在同一时间执行多于一个线程，从而提高性能。

线程是操作系统能够进行运行运算调度的最小单位，一条线程指的是进程中一个单一顺序的控制流。例如main函数就是一个线程。

进程是执行程序的一次执行过程，是由系统分配的资源单位。一个进程里面可以包含多个线程。

Thread类是java.lang.Object类下的，实现线程有三种方法，继承Thread类，实现Runnable接口，实现callable接口。

继承Thread类并重写run()方法，调用start()方法

public class ThreadDemo1 extends Thread{
    //重写run()方法
    @Override
    public void run() {
        for (int i = 1; i <= 100; i++) {
            System.out.println("继承Thread类测试，下标："+ i);
        }
    }
​
    public static void main(String[] args) {
        //执行start()方法
        new ThreadDemo1().start();
        
        for (int i = 0; i < 2000; i++) {
            System.out.println("main方法测试,下标："+ i);
        }
​
    }
}

注意：当调用run()方法时，程序会执行，但是是按照程序顺序执行的，但是调用start()方法时程序是同时执行的。

实现Runnable接口并重写run()方法，调用start()方法

public class ThreadDemo2 implements Runnable {
    //重写run()方法
    @Override
    public void run() {
        for (int i = 1; i <= 100; i++) {
            System.out.println("实现Runnable接口测试，下标："+ i);
        }
    }
​
    public static void main(String[] args) {
​
        //调用start()方法
        ThreadDemo2 threadDemo2 = new ThreadDemo2();
        new Thread(threadDemo2).start();
​
        for (int i = 0; i < 2000; i++) {
            System.out.println("main方法测试,下标："+ i);
        }
        
    }
}

实现Callable接口，重写call()方法，通过创建服务，提交任务，获取结果，关闭服务。

这种方式较前两种方式新增了返回值类型定义及可以抛出异常。

public class ThreadDemo3 implements Callable {
    @Override
    public String call() throws Exception {
        String str = "实现Callable接口";
        return str;
    }
​
    public static void main(String[] args) throws ExecutionException, InterruptedException {
​
        ThreadDemo3 th1= new ThreadDemo3();
        ThreadDemo3 th2= new ThreadDemo3();
        //创建执行服务
        ExecutorService executorService = Executors.newFixedThreadPool(2);
​
        //提交任务
        Future submit1 = executorService.submit(th1);
        Future submit2 = executorService.submit(th2);
​
        //获取结果
        String s1 = submit1.get();
        String s2 = submit2.get();
        System.out.println(s1);
        System.out.println(s2);
​
        //关闭服务
        executorService.shutdown();
    }
}

public class RabbitAndTurtleRace implements Runnable{
    //设置胜利者
    private static String winner;
    @Override
    public void run() {
​
        for (int i = 1; i <= 100; i++) {
​
            //模拟兔子睡觉
            if(Thread.currentThread().getName().equals("兔子") && i%10 == 0){
                try {
                    Thread.sleep(200);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            
            //判断游戏是否结束
            Boolean flag = gaveOver(i);
            if(!flag){
                System.out.println(Thread.currentThread().getName()+"--->跑了" + i + "步");
            }
        }
    }
​
    public static void main(String[] args) {
        //设置两个线程
        RabbitAndTurtleRace race= new RabbitAndTurtleRace();
        new Thread(race,"兔子").start();
        new Thread(race,"乌龟").start();
​
    }
    
    public Boolean gaveOver(int step){
        
        if(winner != null){
            return true;
        }
        if(step == 100){
            winner = Thread.currentThread().getName();
            System.out.println("winner is" + winner);
            return true;
        }
        return false;
    }
}
​