【九月打卡】第7天 多线程的安全与应用（上）

课程名称：Java体系课

章节名称：多线程的安全与应用（上）

课程内容：

• 多线程程序的概念
• 创建多线程的三种方式

学习收获：

• 多线程程序的概念

1. 程序是静态文件
2. 进程是程序运行的实例
   当一个程序执行进入内存运行时，即变成一个进程
   进程的资源是彼此隔离的，其他进程不允许访问（如内存空间、文件）
   有的程序可以启动多个进程，但有的只能启动一个
3. 线程是进程内执行的“任务”
   线程是进程内的一个“基本任务”，每个线程都有自己的功能是CPU分配与调度的基本单位
   一个进程内可以包含多个线程，反之一个线程只能隶属于某一个进程
   进程至少有一个“线程”，这个线程叫“主线程”，主线程消亡则进程结束
   单核CPU通过时间片使所有线程达到一个并发执行的效果
   多核CPU达到并行执行的效果
4. Java中的进程与线程
   只有一个main线程的java程序名义上是“单线程”程序
   每个JAVA程序在执行时实际上至少会有两个线程，会自动添加一个垃圾收集的线程。

• 创建多线程的三种方式

1、继承Thread类创建线程

步骤：
1、创建Thread类的子类，重写run（）方法
2、实例化该子类对象
3、调用start（）方法
例子：

public class ThreadSample1 {
    class Runner extends Thread{
        @Override
        public void run() {
            Integer speed = new Random().nextInt(10);
            for(int i = 1 ; i <= 10 ; i++){
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("第" + i + "秒：" + this.getName() + "已跑到" + (i * speed) + "米（" + speed + "米/秒)");
            }
        }
    }

    public void start(){
        Runner threadA = new Runner();
        threadA.setName("参赛者A");
        Runner threadB = new Runner();
        threadB.setName("参赛者B");
        Runner threadC = new Runner();
        threadC.setName("参赛者C");
        Runner threadD = new Runner();
        threadD.setName("参赛者D");

        threadA.start();
        threadB.start();
        threadC.start();
        threadD.start();
    }

    public static void main(String[] args) {
        //System.out.println("参赛者A 10秒跑了100米");
        //System.out.println("参赛者B 10秒跑了60米");
        //System.out.println("参赛者C 10秒跑了80米");
        new ThreadSample1().start();
    }
}

2、实现Runnable接口创建线程

步骤：
1、声明实现Runnable接口的类
2、在实现类内实现run（）方法
3、创建实现类对象
4、通过实现类对象创建线程类的对象
5、调用start（）方法启动线程
例子：

public class ThreadSample2 {
    class Runner implements Runnable{
        @Override
        public void run() {
            Integer speed = new Random().nextInt(10);
            for(int i = 1 ; i <= 10 ; i++){
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("第" + i + "秒：" + Thread.currentThread().getName() + "已跑到" + (i * speed) + "米（" + speed + "米/秒)");
            }
        }
    }

    public void start(){
        Runner runner = new Runner();
        Thread threadA = new Thread(runner);
        threadA.setName("参赛者A");
        Thread threadB = new Thread(new Runner());
        threadB.setName("参赛者B");
        Thread threadC = new Thread(new Runner());
        threadC.setName("参赛者C");

        threadA.start();
        threadB.start();
        threadC.start();
    }

3、实现Callable接口创建线程

步骤：
1、声明实现Callable接口的类
2、在实现类中实现call（）方法
3、创建线程池
4、创建实现类对象
5、将对象放入线程池并接收返回值
6、关闭线程池
例子：

public class ThreadSample3 {
   class Runner implements Callable<Integer>{
       public String name;
       @Override
       public Integer call() throws Exception {
           Integer speed = new Random().nextInt(10);
           Integer result = 0;
           for(int i = 1 ; i <= 10 ; i++){
               Thread.sleep(1000);
               result = i * speed;
               System.out.println("第" + i + "秒：" + this.name + "已跑到" + (i * speed) + "米（" + speed + "米/秒)");
           }
           return result;
       }
   }

   public void start() throws ExecutionException, InterruptedException {
       //创建线程池
       ExecutorService executorService = Executors.newFixedThreadPool(3);
       Runner threadA = new Runner();
       threadA.name = "参赛者A";
       Runner threadB = new Runner();
       threadB.name = "参赛者B";
       Runner threadC = new Runner();
       threadC.name = "参赛者C";
       //利用Future对象获取每一个线程执行后的结果
       Future<Integer> r1 = executorService.submit(threadA);
       Future<Integer> r2 = executorService.submit(threadB);
       Future<Integer> r3 = executorService.submit(threadC);
       //关闭线程池
       executorService.shutdown();
       System.out.println(threadA.name + "累计跑了" + r1.get() + "米");
       System.out.println(threadB.name + "累计跑了" + r2.get() + "米");
       System.out.println(threadC.name + "累计跑了" + r3.get() + "米");
   }

• 三种创建多线程的方式对比
  继承Thread，Java对继承不友好，不推荐使用
  实现Runnable接口，Java编程友好，但无法返回执行后数据
  实现Callable接口，可以返回多线程执行结果，编程首显复杂

课程截图