多线程简介及创建

一、线程简介

• 普通方法调用和多线程

• 一个进程中可以有多个线程，如视频中同时出现的声音、图像、字幕等。

Process 与 Thread

• 进程与程序相比，程序是指令和数据的有序集合，本事没有任何进行的含义，是一个静态的概念；进程是执行程序的一次执行过程，是动态的概念，是系统资源分配的单位。
• 通常进程中包含多个线程，一个进程至少有一个线程，不然没有存在的意义。线程是CPU调度和执行的单位。
• 注意：很多线程是模拟出来的，真正的多线程是指有多个CPU（即多核），如服务器。如果是模拟出来的多线程，即在一个CPU的情况下，在同一时间点CPU只能执行一个代码，因为切换的快，就产生同时执行的错觉。

核心概念

1. 线程：独立的执行路径。
2. 在程序运行时即使没有自己创建线程，后台也会有多个线程：如主线程（main）、gc线程（垃圾回收线程）。
3. main（）称之为主线程，为系统的入口，用于执行整个程序。
4. 在一个程序中，如果开辟了多个线程，线程的运行由调度器安排调度，调度器是与操作系统紧密相关的，先后顺序是不能人为干预的。
5. 对同一份资源操作时，会出现资源抢夺问题，需要加入并发控制。
6. 线程会带来额外的开销，如CPU调度时间，并发控制开销。
7. 每个线程在自己的工作内存交互，内存控制不当会造成数据不一致。

二、线程创建

三种实现方式

1. Thread class：继承Thread类（源码是实现了Runnable接口）
   • 常用方法：Thread.currentThread().getName();
2. Runnable 接口：实现Runnable接口（可实现多线程操作同一对象，如：买票）
3. Callable 接口：实现Callable接口（好像企业中常用，但是本文介绍的不多）

Thread

• 自定义线程类继承Thread类
• 重写run()方法，编写线程执行体
• 创建线程对象，调用start()方法启动线程
• 线程不一定启动，听CPU调度

public class TestThread1 extends Thread{
    @Override//先修改线程执行体
    public void run() {
        //run方法线程体
        for (int i = 0; i < 20; i++) {
            System.out.println("a"+i);
        }
    }
    public static void main(String[] args) {
        //main线程，主线程
        //创建一个线程对象
        TestThread1 testThread1 = new TestThread1();
        //调用start方法开启线程
        testThread1.start();
        for (int i = 0; i < 200; i++) {
            System.out.println("b"+i);
            //结果：a、b交替出现，每次执行结果不同
        }
    }
}

案例

//下载网络图片
public class TestThread2 extends Thread{
    private String url;
    private String name;

    public TestThread2(String url,String name){
        this.url=url;
        this.name=name;
    }

    @Override
    public void run() {
        WebDownloader webDownloader = new WebDownloader();
        webDownloader.downloader(url,name);
        System.out.println("下载文件名："+name);
    }
    public static void main(String[] args) {
        TestThread2 t1 = new TestThread2("");//括号里填url
        
        t1.start();
    }
}

class WebDownloader{
    public void downloader(String url,String name){
        try {
            FileUtils.copyURlToFile(new URL(url),new File(name));
        } catch (IOException e) {
            e.printStackTrace();
            System.out.println("IO异常，download方法出现问题");
        }
    }
}

实现Runnable接口

• 定义MyRunnable类实现Runnable接口
• 实现run()方法，编写线程体
• 创建线程对象，调用start()方法启动线程

//线程创建方式2：实现Runnable接口，实现run()方法
public class TestThread3 implements Runnable{
    public void run() {
        //run方法线程体
        for (int i = 0; i < 20; i++) {
            System.out.println("a"+i);
        }
    }

    public static void main(String[] args) {
        //创建Runnable接口实现类对象
        TestThread3 testThread3 = new TestThread3();
//        Thread thread = new Thread(testThread3);
//        thread.start();
        //与
        new Thread(testThread3).start();

        for (int i = 0; i < 200; i++) {
            System.out.println("b"+i);
        }
    }
}

小结

• 继承Thread类
  • 子类继承Thread类具备多线程能力
  • 启动线程：子类对象.start();
  • 不建议使用，避免OOP单继承的局限性
• 实现Runnable接口
  • 实现接口Runnable具有多线程能力
  • 启动线程：传入目标对象+Thread对象.start()；
  • 推荐使用：避免单继承的局限，方便一个对象被多个线程使用

并发问题：多个线程操作同一个对象

//模拟抢票
//发现问题：多个线程操作同一个资源的情况下，线程不安全，数据紊乱
public class TestThread4 implements Runnable{
    private int ticketnum = 10;
    
    @Override
    public void run(){
        while(true){
            if(ticket<=0){break;}
            //模拟延时
            try{
                Thread.sleep(200);
            }catch(InterruptedException e){
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+"->拿到了第"+ticketnum--+"票");
        }
    }
    public static void main(String[] args){
        TestThread4 ticket = new TestThread();
        new Thread(ticket,"大雄").start(); 
        new Thread(ticket,"胖虎").start(); 
        new Thread(ticket,"小夫").start(); 
    }
}

案例：龟兔赛跑

1. 首先创建赛道距离，要离终点越来越近
2. 判断比赛是否结束
3. 打印胜利者
4. 龟兔赛跑
5. 设置兔子睡觉
6. winner

public class Race implements Runnable{
   private static String winner;

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

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

   private boolean gameOver(int steps){
       if (winner!=null){return true;}
       {
           if(steps>=100){
               winner = Thread.currentThread().getName();
               System.out.println("Winner is "+winner);
               return true;
           }
       }
       return false;
   }

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

   }

}

实现Callable接口

1. 需要返回值类型
2. 重写call方法
3. 创建目标对象
4. 创建执行服务：ExecutorService ser= Executor.newFixedThreadPool(1);
5. 提交执行：Future result1 = ser.submit(t1);
6. 获取结果：boolean r1 = result1.get();
7. 关闭服务：ser.shutdownNow();