Java多线程01

• 多任务
• 多线程
• 普通方法调用和多线程
  
• 程序 进程 线程
  • 在操作系统中运行的程序就是进程
  • 一个进程可以有多个线程，如视频中同时听声音，看图像，看弹幕等
• Process与Thread
  • 说起进程，就不得不说程序。程序是指令和数据的有序集合，其本身没有任何运行的含义，是一个静态的概念。
  • 而进程则是执行程序的一次执行过程，它是一个动态的概念。是系统资源分配的单位
  • 通常在一个进程中可以包含若干个线程，当然一个进程中至少有一个线程，不然没有存在的意义。线程是CPU调度和执行的单位。

  注意：很多多线程是模拟出来的，真正的多线程是指有多个CPU，即多核，如服务器。如果是模拟出来的多线程，即在一个CPU的情况下，在同一个时间点，
  CPU只能执行一个代码，因为切换的很快，所以就有同时执行的错局。
  

• 核心概念
  • 线程就是独立的执行路径；
  • 在程序运行时，即使没有自己创建线程，后台也会有多个线程，如主线程，GC线程；
  • main()称之为主线程，为系统的入口，用于执行整个程序；
  • 在一个进程中，如果开辟了多个线程，线程的运行由调度器安排调度，调度器是与操作系统紧密相关的，先后顺序是不能人为干预的；
  • 对同一份资源操作时，会存在资源抢夺的问题，需要加入并发机制；
  • 线程会带来额外的开销，如CPU调度时间，并发控制开销；
  • 每个线程在自己的工作内存交互，内存控制不当会造成数据不一致。

• 三种创建方法
  
• 继承Thread
  • 自定义线程类继承Thread类
  • 重写run() 方法，编写线程执行体
  • 创建线程对象，调用start() 方法启动线程
  • 不建议使用：避免OOP单继承局限性

public class TestThread extends Thread {

    @Override
    public void run() {
        // run方法线程体
        for (int i = 0; i < 20; i++) {
            System.out.println("check code " + i);
        }
    }

    public static void main(String[] args) {
        // main线程，主线程

        // 创建一个线程对象
        TestThread thread = new TestThread();
        // 调用start()方法开启线程
        thread.start();

        for (int i = 0; i < 20; i++) {
            System.out.println("learn thread " + i);
        }
    }
}

• 实现Runnable
  • 定义MyRunnable类实现Runnable接口
  • 实现run() 方法，编写线程执行体
  • 创建线程对象，调用start() 方法启动线程
  • 推荐使用：避免单继承局限性，灵活方便，方便同一个对象被多个线程使用

public class TestThread implements Runnable {
    @Override
    public void run() {
        // run方法线程体
        for (int i = 0; i < 20; i++) {
            System.out.println("check code " + i);
        }
    }

    public static void main(String[] args) {
        // 创建Runnable接口的实现类对象
        TestThread testThread = new TestThread();
        // 创建线程对象，通过线程对象来开启我们的线程，代理
        new Thread(testThread).start();

        for (int i = 0; i < 20; i++) {
            System.out.println("learn thread " + i);
        }
    }
}

public class Race implements Runnable {
    private static String winner;

    @Override
    public void run() {
        for (int i = 0; i <= 100; i++) {
            // 模拟兔子睡觉
            String threadName = Thread.currentThread().getName();
            if ("兔子".equals(threadName) && i % 20 == 0) {
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }

            // 判断比赛是否结束
            boolean flag = gameOver(i);
            if (flag) {
                break;
            }
            System.out.println(threadName + "-->跑了" + i + "步");
        }
    }


    
    private boolean gameOver(int steps) {
        // 判断是否由胜利者
        if (winner != null) {
            return true;
        } else if (steps == 100) {
            winner = Thread.currentThread().getName();
            System.out.println("winner is " + winner);
            return true;
        } else {
            return false;
        }
    }

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

• 实现Callable
  • 实现Callable接口，需要返回值类型
  • 重写call方法，需要抛出异常
  • 创建目标对象

public class TestCallable implements Callable {
    private String name;

    private TestCallable(String name) {
        this.name = name;
    }

    @Override
    public Boolean call() {
        System.out.println("check code " + name);
        return true;
    }

    public static void main(String[] args) {
        TestCallable c1 = new TestCallable("a");
        TestCallable c2 = new TestCallable("b");
        TestCallable c3 = new TestCallable("c");

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

        // 提交执行
        Future s1 = service.submit(c1);
        Future s2 = service.submit(c2);
        Future s3 = service.submit(c3);

        // 获取结果
        try {
            Boolean b1 = s1.get();
            Boolean b2 = s2.get();
            Boolean b3 = s3.get();
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        }

        // 关闭服务
        service.shutdownNow();
    }
}