JavaSE多线程01 2021.05.26-27

多花时间学习，提高效率，提高专注度
加油！

1 Process与Thread 进程与线程

• 一个进程可以有多个线程，如视频中同时听声音，看图像，看弹幕等。
• 程序是指令和数据的有序集合，是一个静态概念
• 进程是执行程序的一次执行过程，是一个动态概念。是系统资源分配的单位
• 通常一个进程中可以包含若干个线程，当然一个进程中至少有一个线程，线程是CPU调度和执行的单位
• 注意：真正的多线程是指有多个cpu，即多核，如服务器。如果是模拟出来的多线程，即在一个cpu的情况下，同一时间cpu只能执行一个代码，因为切换很快，就有同事执行的错觉。
  

2 线程创建

一、继承Thread类，重写run()方法，调用start()方法开启线程

public class TestThread01 extends Thread{
    @Override
    public void run() {
        //run方法线程体
        for (int i = 0; i < 20; i++) {
            System.out.println("吃饭"+i);
        }
    }
    
    public static void main(String[] args) {//main线程，主线程
        TestThread01 testThread01 = new TestThread01();//创建一个线程对象

        testThread01.start();//调用start()方法开启线程

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

注意：线程开启不一定立即执行，由cpu调度执行

二、实现Runnable接口，重写run()方法，丢入runnable接口实现类，调用Thread的start()方法。

public class TestThread02 implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            System.out.println("吃饭"+i);
        }
    }
    
    public static void main(String[] args) {
        TestThread02 testThread02 = new TestThread02();//创建runnable接口的实现类对象
        
        //创建线程对象，通过线程对象来开启线程，代理
//        Thread thread = new Thread(testThread02);
//        thread.start();

        new Thread(testThread02).start();
        
        for (int i = 0; i < 200; i++) {
            System.out.println("看电视"+i);
        }
    }
}

小结

继承thread类：

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

实现Runnable接口

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

3 初始并发问题

多个线程操作同一个资源的情况下，线程不安全，数据紊乱

//多个线程同时操作同一个对象
//买火车票

//发现问题：多个线程操作同一个资源的情况下，线程不安全，数据紊乱
public class TestThread03 implements Runnable {

    //票数
    private int ticketNums=10 ;

    @Override
    public void run() {
        while(true){
            if (ticketNums<=0){
                break;
            }

            //模拟延时
//            try {
//                Thread.sleep(200);
//            } catch (InterruptedException e) {
//                e.printStackTrace();
//            }

            System.out.println(Thread.currentThread().getName()+"拿到了第"+ticketNums+"票");
            ticketNums--;
        }
    }

    public static void main(String[] args) {

        TestThread03 ticket = new TestThread03();

        new Thread(ticket,"碧咸").start();
        new Thread(ticket,"泳琳").start();
        new Thread(ticket,"猪猪").start();
    }
}

4 龟兔赛跑

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%10==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 i){
        //判断是否有胜利者
        if (winner!=null){//已经存在胜利者
            return true;
        }
            if (i >= 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();
    }
}

5 实现Callable接口（暂时先了解）