目录

多线程

1.1 并发和并行 

1.2 线程和进程 

1.2.1 进程

1.2.2 线程

1.3 单线程 

1.3.1 单线程案例 

1.4 创建多线程的方式

1.4.1 继承Thread类

1.4.2 实现Runnable接口

1.4.3  使用匿名内部类

1.5 Thread类

1.5.1 构造方法

1.5.2 常用方法 

1.5.3 Thread类中的常用方法练习

---

多线程

        指在一个程序中同时运行多个线程，每个线程可以执行不同的任务。多线程可以提高程序的性能和响应速度，充分利用计算机的多核处理能力。同时，多线程也可以实现任务的并发执行，提升程序的效率。多线程之间可以共享数据，但也需要注意线程安全的问题。 

1.1 并发和并行 

• 并发：指两个或多个事件在同一个时间段内发生（交替执行）。
• 并行：指两个或多个事件在同一时刻发生（同时执行）。

1.2 进程和线程 

1.2.1 进程

        指一个内存中运行的应用程序，每一个进程都有一个独立的内存空间，一个应用程序可以同时运行多个进程，进程也是程序的一次执行过程，是系统运行程序的基本单位，系统运行一个程序即是一个进程从创建、运行到消亡的过程。

1.2.2 线程

        线程是进程中的一个执行单元，负责当前进程中程序的执行，一个进程中至少有一个线程，一个进程中是可以有多个线程的，这个应用程序也可以称之为多线程程序。

注：一个程序运行后至少有一个进程，一个进程中可以包含多个线程。  

1.3 单线程 

        指java程序只有一个线程（main方法的线程），执行从main方法开始，从上到下依次执行，执行过程如下：

1. JVM执行main方法，main方法会进入到栈内存。
2. JVM会找操作系统开辟一条main方法通向CPU的执行路径。
3. CPU就可以通过这个路径来执行main方法。
4. 而这个路径有一个名字，叫（main）主线程。

1.3.1 单线程案例 

场景：

        模拟王者游戏中，两组英雄进行攻击（米莱迪 攻击 诸葛亮 and 亚瑟 攻击 猪八戒），下面是采用单线程的方式实现。

Hero.java（角色类） 

package com.zhy.multiplethread;

public class Hero{
    /**
     * 角色名称
     */
    public String name;
    /**
     * 角色血量
     */
    public float hp;
    /**
     * 攻击伤害
     */
    public int damage;
    
    public Hero(){   
    }
    
    public Hero(String name,float hp,int damage){
        this.name = name;
        this.hp = hp;
        this.damage = damage;
    }

    /**
     * 角色攻击方法
     * @param h
     */
    public void attackHero(Hero h) {
        try {
            //攻击需要时间，每次攻击暂停1000毫秒
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        //每次攻击，角色的血量逐渐减少
        h.hp -= damage;
        System.out.format("%s 正在攻击 %s, %s 的血变成了 %.0f%n",name,h.name,h.name,h.hp);

        if(h.isDead()){
            System.out.println(h.name +" 已被击杀！");
        }
    }

    /**
     * 判断角色是否已被击杀（根据血量判断），血量>=0：返回true，否则：返回false
     * @return
     */
    public boolean isDead() {
        return 0 >= hp ? true : false;
    }
}

TestThread.java（测试类） 

package com.zhy.multiplethread;

public class TestThread {
    public static void main(String[] args) {
        Hero hero1 = new Hero("米莱迪",350,60);
        Hero hero2 = new Hero("诸葛亮",300,50);
        Hero hero3 = new Hero("亚瑟",450,70);
        Hero hero4 = new Hero("猪八戒",400,60);

        //米莱迪 攻击 诸葛亮
        while(!hero2.isDead()){
            hero1.attackHero(hero2);
        }

        //亚瑟 攻击 猪八戒
        while(!hero4.isDead()){
            hero3.attackHero(hero4);
        }
    }
}

输出结果：

        使用单线程实现，可以看出，第二组英雄 是在 第一组英雄攻击完毕后 才开始攻击的。

1.4 创建多线程的方式

        创建多线程的常用方式有三种，第一种是继承Thread类；第二种是实现Runnable接口；第三种是直接使用匿名内部类进行具体实现。下面我们依次进行详细解析。

1.4.1 继承Thread类

        java.lang.Thread类：Java线程模型的基础，只需要继承Thread类并重写run()方法来定义线程的执行逻辑。然后可以通过创建Thread的实例来启动线程。

实现步骤：

1. 创建一个Thread类的子类。
2. 在Thread类的子类中重写Thread类中的run()方法，设置线程任务（具体业务场景）。
3. 创建Thread类的子类对象为实例。
4. 调用Thread类中的start方法，开启新的线程，实际是执行的run()方法。

        

注意事项：

• void start()：使该线程开始执行；java虚拟机调用该线程的run()方法。
• 启动线程后，实际是两个线程并发的运行，当前线程（main线程）和另一个线程（创建的新线程，执行其run()方法）。
• 多次启动一个线程是非法的，特别是当线程已经结束执行后，不能在重新启动。​​​​​​ 

代码示例：  

场景：

        模拟王者游戏中，两组英雄进行攻击（米莱迪 攻击 诸葛亮 and 亚瑟 攻击 猪八戒），下面是采用多线程的方式实现。

KillThread.java（Thread的子类） 

package com.zhy.multiplethread;

/**
 * 1.创建一个Thread类的子类。
 */
public class KillThread extends Thread{

    private Hero h1;
    private Hero h2;

    public KillThread(Hero h1, Hero h2){
        this.h1 = h1;
        this.h2 = h2;
    }

    /**
     * 2.在子类中重写Thread类中的run()方法，设置线程任务。
     *  当角色h2没有被击杀时，角色h1持续进行攻击
     */
    public void run(){
        while(!h2.isDead()){
            h1.attackHero(h2);
        }
    }
}

 TestThread.java（测试类） 

package com.zhy.multiplethread;

public class TestThread {
    public static void main(String[] args) {
        Hero hero1 = new Hero("米莱迪",350,60);
        Hero hero2 = new Hero("诸葛亮",300,50);
        Hero hero3 = new Hero("亚瑟",450,70);
        Hero hero4 = new Hero("猪八戒",400,60);

        //3.创建Thread类的子类对象
        KillThread killThread1 = new KillThread(hero1,hero2);
        KillThread killThread2 = new KillThread(hero3,hero4);
        //4.调用Thread类中的start方法，开启新的线程，实际是执行的run()方法。
        killThread1.start();
        killThread2.start();
    }
}

输出结果：

        java程序属于抢占式调度，哪个线程的优先级高，哪个线程就先执行，同一个优先级，随机选择一个执行。从输出中可以看到，第一组英雄 还没攻击完毕 第二组英雄就开始攻击了，可以很大程度的提高程序的性能和速度。

1.4.2 实现Runnable接口

        java.lang.Runnable接口：实现Runnable接口的类可以作为Thread类的构造函数参数来创建线程。这种方式更加灵活，因为Java不支持多继承，所以实现Runnable接口可以使类在同时继承其他类的情况下创建线程。

构造方法：
        Thread(Runnable target)：分配新的Thread对象。
        Thread(Runnable target,String name)：分配新的Thread对象。

        

实现步骤： 

1. 创建一个Runnable接口的实现类。
2. 在实现类中重写Runnable接口的run方法，设置线程任务。
3. 创建一个Runnable接口的实现类对象。
4. 创建Thread类对象，构造方法中传递Runnable接口的实现类对象。
5. 调用Thread类中的start方法，开启新的线程执行run方法。

代码示例： 

场景同上 

Battle.java（Runnable的实现类）

package com.zhy.multiplethread;

/**
 * 1.创建一个Runnable接口的实现类
 */
public class Battle implements Runnable{

    private Hero h1;
    private Hero h2;

    public Battle(Hero h1, Hero h2){
        this.h1 = h1;
        this.h2 = h2;
    }

    /**
     * 2.在实现类中重写Runnable接口的run方法，设置线程任务
     */
    public void run(){
        while(!h2.isDead()){
            h1.attackHero(h2);
        }
    }
}

 TestThread.java（测试类） 

package com.zhy.multiplethread;

public class TestThread {
    public static void main(String[] args) {
        Hero hero1 = new Hero("米莱迪",350,60);
        Hero hero2 = new Hero("诸葛亮",300,50);
        Hero hero3 = new Hero("亚瑟",450,70);
        Hero hero4 = new Hero("猪八戒",400,60);

        //3.创建一个Runnable接口的实现类对象
        Battle battle1 = new Battle(hero1,hero2);
        Battle battle2 = new Battle(hero3,hero4);
        //4.创建Thread类对象，构造方法中传递Runnable接口的实现类对象;调用Thread类中的start方法，开启新的线程执行run方法
        new Thread(battle1).start();
        new Thread(battle2).start();
    }
}

实现Runnable接口创建多线程程序的好处：

1. 实现了Runnable接口，还可以继承其他的类，实现其他的接口；避免了单继承的局限性。
2. 把设置线程任务和开启新线程进行了分离，增强了程序的扩展性，降低了程序的耦合性（解耦）。

1.4.3  使用匿名内部类

• 匿名：没有名字。
• 内部类：存在其他类内部的类。

格式：

        new 父类/接口(){
                重写父类/接口中的方法
        };

        

作用：简化代码

        

实现方式：

1. 把（子类继承父类，重写父类的方法，创建子类对象）合一步完成。
2. 把（实现类实现接口，重写接口中的方法，创建实现类对象）合成一步完成。
3. 匿名内部类的最终产物：子类/实现类对象，而这个类没有名字。

代码示例： 

场景同上 

 TestThread.java（测试类） 

package com.zhy.multiplethread;

public class TestThread {
    public static void main(String[] args) {
        Hero hero1 = new Hero("米莱迪",350,60);
        Hero hero2 = new Hero("诸葛亮",300,50);
        Hero hero3 = new Hero("亚瑟",450,70);
        Hero hero4 = new Hero("猪八戒",400,60);

        //匿名类：线程的父类是Thread
        new Thread(){
            public void run(){
                while(!hero2.isDead()){
                    hero1.attackHero(hero2);
                }
            }
        }.start();

        //匿名类：线程的接口是Runnable
        new Thread(new Runnable() {
            @Override
            public void run() {
                while(!hero4.isDead()){
                    hero3.attackHero(hero4);
                }
            }
        }).start();
    }
}

1.5 Thread类

1.5.1 构造方法

• Thread()：分配一个新线程对象。
• Thread(String name)：分配一个指定名字的新线程对象。
• Thread(Runnable target)：分配一个带有指定目标的新线程对象。
• Thread(Runnable target,String name)：分配一个带有指定目标的新线程对象并指定名字。

1.5.2 常用方法 

• String getName()：获取当前线程的名称。
• void start()：启动当前线程，java虚拟机调用当前线程的run方法。
• void run()：当前线程要执行的任务在此处定义代码。
• static void sleep(long millis)：使当前正在执行的线程以指定的毫秒数暂停。
• static Thread currentThread()：返回对当前正在执行的线程对象的引用。

1.5.3 Thread类中的常用方法练习

场景：模拟 秒针 的转动，每隔一秒执行依次。 

package com.zhy.thread;

//继承自Thread类
public class ThreadTest extends Thread{

    //定义一个无参构造方法
    public ThreadTest(){
    }

    //定义一个有参构造方法
    public ThreadTest(String name){
        super(name);
    }

    //重写父类中的run方法
    @Override
    public void run() {
        //获取当前正在执行的线程对象
        Thread thread = Thread.currentThread();
        //获取当前线程的名称
        String threadName = thread.getName();
        System.out.println(threadName);

        //也可以直接分成一步实现，采用链式编程
        System.out.println(Thread.currentThread().getName());
    }

    public static void main(String[] args) {
        //启动多线程1
        ThreadTest threadTest = new ThreadTest();
        threadTest.setName("xiaoQiang");
        threadTest.start();

        //启动多线程2
        new ThreadTest("wancai").start();

        //模拟秒针，每隔一秒执行一次
        for (int i = 1; i <= 60; i++){
            System.out.println(i);
            try {
                //该方法是一个编译时异常，必须处理
                Thread.sleep(1000);
            }catch (InterruptedException e){
                e.printStackTrace();
            }
        }
    }
}