用王者荣耀让你理解什么是多线程 Java

线程和进程

进程：是正在运行的，进程是资源分配的最小单位
线程：是cpu调度的最小单位，线程依赖于进程

是不是感觉不好理解，打个比方，好比你打了一把王者荣耀，进程比作是你开的那把游戏，线程比作每个玩家所选的英雄或者游戏中的水晶野怪之类的。带着这个比方，来理解进程和线程的一些关系。
一个进程有多个线程就叫多线程。 这句话是不是很好理解。

1，线程在进程下进行

比如你单独的英雄角色，野怪，小兵肯定不能运行

2，进程之间不会相互影响，一个线程结束将会导致整个进程的结束

两把游戏之间不会有联系和影响。你的水晶被推掉了，只有你这把游戏结束了.

3，不同线程的进程的数据很难共享

两把游戏之间很难有联系

4，同进程下的不同线程之间的数据很容易共享

你在打的这把游戏，你可以看到每个玩家的出装和状态等

5，进程使用内存地址可以限定使用量

开的房间模式，决定了你可以设置有多少人进，当房间满了后，其他人就进不去了，除非有人退出房间，其他人才能进

多线程的创建

多线程创建的两种方式：

• 1，创建一个类继承Thread类，并重写run() 方法。
• 2，创建一个类实现Runnable接口，并重写run() 方法。

1，创建一个类继承Thread类，并重写run() 方法。

public class MyThread extends Thread{
    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println(getName() + "打了" + i + "个小兵");
        }
    }
}
    public static void main(String[] args) {
        // 创建MyThread对象
        MyThread t1 = new MyThread();
        MyThread t2 = new MyThread();
        MyThread t3 = new MyThread();
        // 设置线程名字
        t1.setName("虞姬");
        t2.setName("狄仁杰");
        t3.setName("马可波罗");
        // 启动线程
        t1.start();
        t2.start();
        t3.start();
    }

执行结果：

2，创建一个类实现Runnable接口，并重写run() 方法。

public class MyRunnable implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            try {
                Thread.sleep(20);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+ "打了" + i + "个小兵");
        }
    }
}
MyRunnable mr = new MyRunnable();
        // 创建Thread类的有参构造，并设置线程名
        Thread r1 = new Thread(mr,"虞姬");
        Thread r2 = new Thread(mr,"狄仁杰");
        Thread r3 = new Thread(mr,"马可波罗");
        // 启动线程
        r1.start();
        r2.start();
        r3.start();
        

执行结果：

1，为什么要重写run方法

因为run方法是用来封装被线程执行的代码

2，run()和start()有什么区别

• run():封装线程执行的代码，直接调用相当于调用普通方法
• start():启动线程，然后由JVM调用此线程的run() 方法；

3，通过继承Thread的方法实现Runnable 接口的方式创建多线程，哪个好？

实现Runnable接口好，原因有两个：

• 1,避免Java单继承的局限性
• 2，适合多个相同的代码去处理同一个资源的情况，把线程，代码和数据有效的分离，更符合面向对象的设计思想。

针对线程控制，大家还会遇到 3 个常见的方法，我们来一一介绍下。

1，sleep():使当前正在执行的线程暂停指定的毫秒数，也就是进入休眠状态。

sleep的时候需要对异常进行处理

        for (int i = 0; i < 10; i++) {
            try { 
                Thread.sleep(20); // 暂停20毫秒
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+ "打了" + i + "个小兵");
        }

2，join()：等待这个线程执行完才会轮到后续线程得到cpu的执行权，使用这个也要抛出异常。

MyRunnable mr = new MyRunnable();
        // 创建Thread类的有参构造，并设置线程名
        Thread r1 = new Thread(mr,"虞姬");
        Thread r2 = new Thread(mr,"狄仁杰");
        Thread r3 = new Thread(mr,"马可波罗");
        // 启动线程
        r1.start();
        try {
            r1.join(); // 等待t1执行完才会轮到t2，t3抢
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        r2.start();
        r3.start();
    }

结果会是：虞姬打完了，狄仁杰和马可抢线程

3，setDaemon()：将此线程标记为守护线程，准确来说，就是服务其他的线程，像 Java 中的垃圾回收线程，就是典型的守护线程。

MyRunnable mr = new MyRunnable();
        // 创建Thread类的有参构造，并设置线程名
        Thread r1 = new Thread(mr,"虞姬");
        Thread r2 = new Thread(mr,"狄仁杰");
        Thread r3 = new Thread(mr,"马可波罗");
        r1.setDaemon(true);
        r2.setDaemon(true);
        // 启动线程
        r1.start();
        r2.start();
        r3.start();

如果其他线程都执行完毕，main 方法（主线程）也执行完毕，JVM 就会退出，也就是停止运行。如果 JVM 都停止运行了，守护线程自然也就停止了。

最后，通过图来理解线程的生命周期