【多线程01-thread、runnable】

1.多线程的核心概念

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

2.线程创建

2.1 Thread（重点）

线程是程序执行的线程，代码没有运行时是静态的代码，代码运行时是进程，线程存在于进程之中。
Thread class 继承Thread类
Thread创建步骤

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

//创建线程方式一：继承Thread类，重run()方法，调用star开启线程
public class Thread1 extends Thread{
    public void run(){
        //run方法线程体
        for (int i = 0; i < 20; i++) {
            System.out.println("reading"+i);
        }
    }

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

        //创建一个线程对象
        Thread1 thread1 = new Thread1();
        thread1.start();
        for (int i = 0; i < 20; i++) {
            System.out.println("playing"+i);
        }
    }
}

练习1：网页图下载（需要下载commons-io的.jar包，地址是http://commons.apache.org/proper/commons-io/）

package Demo01;
import org.apache.commons.io.FileUtils;
import java.io.File;
import java.io.IOException;
import java.net.URL;

//练习Thread，实现多线程下载图片
public class TestThread2 extends Thread{
    private String url;
    private String name;
    //重写构造方法
    public TestThread2(String url,String name){
        this.name = name;
        this.url = url;
    }
    @Override
    public void run() {
        webDownloader webDownloader = new webDownloader();
        webDownloader.downloader(url,name);
        System.out.println("name is :"+name);
    }
    public static void main(String[] args) {
        TestThread2 t1 = new TestThread2("https://img-blog.csdnimg.cn/a017ccfa420142619443e5a70250e777.png#pic_center", "t1");
        TestThread2 t2 = new TestThread2("https://img-blog.csdnimg.cn/698811f0becb43269562906f25a88083.png#pic_center", "t2");
        TestThread2 t3 = new TestThread2("https://img-blog.csdnimg.cn/4765a365ba5f43f08088ed52dc8d2208.png#pic_center", "t3");

        t1.start();
        t2.start();
        t3.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异常，downloader方法出现异常");
        }

    }
}

2.2 Runnable（重点）

推荐使用Runnable对象，因为Java单继承的局限性
实现步骤：

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

package Demo01;

//创建此案成方式二：实现runnable接口，重写run方法，执行线程需要丢入runnable接口实现类
public class Runnable1 implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            System.out.println("reading---"+i);
        }
    }
    public static void main(String[] args) {
        Runnable1 runnable1 = new Runnable1();
//        第一种方法
//        Thread thread = new Thread();
//        thread.start();
//        第二种方法
        new Thread(runnable1).start();
        for (int i = 0; i < 20; i++) {
            System.out.println("playing--"+i);
        }
    }
}

3. 小节

1. 继承Thread类

• 子类继承Thread类具备多线程能力
• 启动线程：子类对象.start()
• 不建议使用：避免OOP单继承局限性

2. 实现Runnable接口

• 实现Runnable接口具备多线程能力
• 启动线程：传入目标对象+Thread对象.start()
• 推荐使用：避免单继承局限性，灵活方便，方便同一个对象被多个线程使用

4. 练习

1. 多线程同时操作同一个对象：抢火车票

//多线程同时操作同一个对象：抢火车票的例子
//发现问题：多个线程操作同一个资源的情况下，线程不安全，数据混乱
public class TestRunnable1 implements Runnable{
    //票数
    private int ticketNums = 10;
    @Override
    public void run() {
        //循环，票数判断
        while (true){
            if(ticketNums<=0){
                break;
            }
            System.out.println(Thread.currentThread().getName()+"拿到了第"+ticketNums--+"票");
        }
    }
    public static void main(String[] args) {
        TestRunnable1 testRunnable1 = new TestRunnable1();
        new Thread(testRunnable1,"anna").start();
        new Thread(testRunnable1,"kim").start();
        new Thread(testRunnable1,"jock").start();
    }

}

2. 龟兔赛跑

完成步骤：

• 首先定义赛道距离，且要离重点越来越近
• 判断比赛是否结束
• 打印出胜利者
• 龟兔赛跑开始
• 模拟兔子睡觉
• 乌龟胜利

package Demo01;
//龟兔赛跑问题
public class TestRunnable2 implements Runnable{
    private static String winner;
    @Override
    public void run() {
        for (int i = 0; i <= 100;i++) {
            //模拟兔子休息
            if(Thread.currentThread().getName().equals("兔子")&& i%50==0){
                try {
                    Thread.sleep(1);//存在异常，捕获异常
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }

            //判断比赛是否结束
            boolean flag = gameOver(i);
            //如果比赛结束，停止程序
            if(flag){
                break;
            }
            System.out.println(Thread.currentThread().getName()+"--跑了"+i+"步");
        }
    }
    //判断是否完成比赛
    public 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) {
        TestRunnable2 testRunnable2 = new TestRunnable2();
        new Thread(testRunnable2,"兔子").start();
        new Thread(testRunnable2,"乌龟").start();
    }
}