十五、多线程(基础)

一、线程介绍

1.1 程序

1.2 进程

1.3 线程

二、线程使用

2.1 创建线程的两种方式

2.2 继承Thread类创建线程

package com.gyh.thread;

/**
 * @author Gao YongHao
 * @version 1.0
 */
public class Thread1 {
    public static void main(String[] args) throws InterruptedException {
        // 创建一个 Cat 对象，可以当成线程使用
        Cat cat = new Cat();

        // 源码解读
        /*

        (1)
        * public synchronized void start() {
        * ...
        *       start0();
        * ...
        * }
        *
        * start0() 是本地方法,是由JVM调用，底层是C/C++实现
        真正实现多线程的效果，是start0(),而不是 run 方法
            private native void start0();
        *
        *
        * */
        cat.start(); // 启动线程，最终会执行cat中的run方法


//        cat.run();// run方法就是一个普通的方法，没有真正的启动一个线程，就会把run方法执行完毕，才向下执行
        // 说明: 当 main 线程启动一个子线程后，主线程不会阻塞,会继续执行
        System.out.println("主线程继续执行" + Thread.currentThread().getName());
        for (int i = 0; i < 60; i++) {
            System.out.println("主线程 i=" + i);
            // 让主线程休眠
            Thread.sleep(1000);
        }
    }
}

// 解读
// 1. 当一个类继承了 Thread 类，该类就可以当做线程使用
// 2. 我们会重写 run 方法，写上自己的业务代码
// 3. run Thread 类 实现了 Runnable 接口的方法
/*
*   @Override
    public void run() {
        if (target != null) {
            target.run();
        }
    }
* */
class Cat extends Thread {
    @Override
    public void run() { // 重写run方法
        int n = 0;
        while (true) {
            // 该线程每隔1s，在控制台输出 "喵喵，我是小猫咪"
            System.out.println("喵喵，我是小猫咪" + (++n) + "线程名" + Thread.currentThread().getName());
            if (n == 80) break;
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

2.3 实现Runnable接口创建线程

package com.gyh.thread;

/**
 * @author Gao YongHao
 * @version 1.0
 */
public class Thread2 {
    public static void main(String[] args) {
        //dog.start(); // 这里不能调用start
        Dog dog = new Dog();
        Thread thread = new Thread(dog);
        thread.start(); // Thread内部使用了 静态代理的设计模式
    }
}

// 模拟Thread中的静态代理
class ThreadProxy implements Runnable {

    private Runnable target;

    @Override
    public void run() {
        if (target != null) target.run();
    }

    public ThreadProxy(Runnable target) {
        this.target = target;
    }

    public void start() {
         start0(); // 这个方法是真正实现多线程方法
    }

    public void start0() {
        run();
    }
}

class Dog implements Runnable { // 通过是实现Runnable接口，开发线程

    @Override
    public void run() { // 普通线程
        int count = 0;
        while (true) {
            System.out.println("小狗汪汪..hi" + (++count) + "Thread name:" + Thread.currentThread().getName());
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

2.4 多线程执行

package com.gyh.thread;

/**
 * @author Gao YongHao
 * @version 1.0
 */
public class Thread3 {
    public static void main(String[] args) {
        Thread01 thread01 = new Thread01();
        Thread02 thread02 = new Thread02();
        thread01.start();
        thread02.start();
    }
}

class Thread01 extends Thread {
    @Override
    public void run() {
        int count = 0;
        while (count < 10) {
            System.out.println("hello,world" + (++count) + "线程名：" + Thread.currentThread().getName());
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

class Thread02 extends Thread {
    @Override
    public void run() {
        int count = 0;
        while (count < 5) {
            System.out.println("hi" + (++count) + "线程名：" + Thread.currentThread().getName());
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

2.5 继承Thread vs 实现 Runnable的区别

package com.gyh.thread;

/**
 * @author Gao YongHao
 * @version 1.0
 */
public class Thread4 {
    public static void main(String[] args) {
//        SellTicket01 sellTicket01 = new SellTicket01();
//        SellTicket01 sellTicket02 = new SellTicket01();
//        SellTicket01 sellTicket03 = new SellTicket01();
//
//        // 这里我们会出现超卖..
//        sellTicket01.start(); // 启动售票线程
//        sellTicket02.start(); // 启动售票线程
//        sellTicket03.start(); // 启动售票线程

        SellTicket2 sellTicket2 = new SellTicket2();
        new Thread(sellTicket2).start(); // 第一个线程--窗口
        new Thread(sellTicket2).start(); // 第二个线程--窗口
        new Thread(sellTicket2).start(); // 第三个线程--窗口
    }
}

// 继承Thread类
class SellTicket01 extends Thread {
    public static int ticketNum = 100;

    @Override
    public void run() {
        while (true) {
            if (ticketNum <= 0) {
                System.out.println("售票结束");
                break;
            }
            try {
                Thread.sleep(50);
                ticketNum--;
                System.out.println("还剩" + ticketNum + "张票");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

class SellTicket2 implements Runnable {
    private static int ticketNum = 100;

    @Override
    public void run() {
        while (true) {
            if (ticketNum <= 0) {
                System.out.println("售票结束");
                break;
            }
            try {
                Thread.sleep(50);
                ticketNum--;
                System.out.println("还剩" + ticketNum + "张票");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

2.6 线程终止

package com.gyh.thread;

/**
 * @author Gao YongHao
 * @version 1.0
 */
public class Thread5 {
    public static void main(String[] args) {
        T t1 = new T();
        t1.start();

        // 如果希望main线程去控制 t1 线程的终止，唏嘘可以修改 loop
        // 让 t1 退出run方法，从而终止 t1线程 -> 通知方式
        try {
            System.out.println("主线程休眠10s");
            Thread.sleep(10000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        t1.setLoop(false);
    }
}

class T extends Thread {
    private int count = 0;
    // 设置一个控制变量
    private boolean loop = true;

    @Override
    public void run() {
        while (loop) {
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("T 运行中....");
        }
    }

    public void setLoop(boolean loop) {
        this.loop = loop;
    }
}

三、线程方法

3.1 常用方法

package com.gyh.thread;

/**
 * @author Gao YongHao
 * @version 1.0
 */
public class ThreadMethod {
    public static void main(String[] args) throws InterruptedException {
        T1 t = new T1();
        t.setName("老韩");
        t.setPriority(Thread.MIN_PRIORITY);
        t.start(); // 启动子线程

        System.out.println(t.getPriority());

        // 主线程打印 5 hi,然后我就终端 子线程的休眠
        for (int i = 0; i < 5; i++) {
            Thread.sleep(1000);
            System.out.println("hi " + i);
        }

        t.interrupt(); // 当执行到这里，就会终端 t线程的休眠
    }
}

class T1 extends Thread {
    @Override
    public void run() {
        while (true) {
            for (int i = 0; i < 100; i++) {
                // Thread.currentThread().getName() 获取当前线程的名称
                System.out.println(Thread.currentThread().getName() + "吃包子~~~~" + i);
            }

            try {
                System.out.println(Thread.currentThread().getName() + "休眠中~~~");
                Thread.sleep(20000); // 20s
            } catch (InterruptedException e) {
//                e.printStackTrace();
                // 当该线程执行到一个interrupt方法时，就会catch一个异常，可以加入自己的业务代码
                // InterruptedException 捕捉到一个中断异常
                System.out.println(Thread.currentThread().getName() + "被 interrupt了");
            }
        }
    }
}

package com.gyh.thread;

/**
 * @author Gao YongHao
 * @version 1.0
 */
public class Thread6 {
    public static void main(String[] args) throws InterruptedException {
        SubThread subThread = new SubThread();
        subThread.start();
        for (int i = 0; i < 20; i++) {
            System.out.println(Thread.currentThread().getName() + ":hi");
            Thread.sleep(1000);
            if (i == 4) subThread.join();
        }
    }
}

class SubThread extends Thread {
    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            System.out.println(Thread.currentThread().getName() + "hello");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

3.2 用户线程和守护线程

package com.gyh.thread;

/**
 * @author Gao YongHao
 * @version 1.0
 */
public class Thread7 {
    public static void main(String[] args) throws InterruptedException {
        ProtectSubThread protectSubThread = new ProtectSubThread();
        //如果我们希望当main线程结束后,子线程该自动结束
        // 只需要将子线程设置为守护线程即可
        protectSubThread.setDaemon(true);
        protectSubThread.start();
        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName() + ":hi " + i);
            Thread.sleep(1000);
        }
    }
}

class ProtectSubThread extends Thread {
    @Override
    public void run() {
        while (true) {
            try {
                System.out.println(Thread.currentThread().getName() + ":hello");
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

四、线程生命周期

package com.gyh.thread;

/**
 * @author Gao YongHao
 * @version 1.0
 */
public class Thread8 {
    public static void main(String[] args) throws InterruptedException {
        Runnable t = new Runnable() {
            @Override
            public void run() {
                while (true) {
                    for (int i = 0; i < 10; i++) {
                        System.out.println("hi " + i);
                        try {
                            Thread.sleep(1000);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                    break;
                }
            }
        };

        Thread thread = new Thread(t);
        System.out.println(thread.getName() + " 状态 " + thread.getState());
        thread.start();
        while (Thread.State.TERMINATED != thread.getState()) {
            System.out.println(thread.getName() + " 状态 " + thread.getState());
            Thread.sleep(500);
        }

        System.out.println(thread.getName() + " 状态 " + thread.getState());
    }
}

五、Synchronized

5.1 线程同步机制

package com.gyh.thread;

/**
 * @author Gao YongHao
 * @version 1.0
 */
public class Thread9 {
    public static void main(String[] args) {
        SubSellTicket subSellTicket = new SubSellTicket();
        new Thread(subSellTicket).start();
        new Thread(subSellTicket).start();
        new Thread(subSellTicket).start();
    }
}

// 实现接口方式，使用 synchronized 实现线程同步
class SubSellTicket implements Runnable {
    private static int ticketNum = 100;
    private boolean loop = true; // 设置结束条件

    public synchronized void sell() { // 同步方法, 在同一时刻，只能有一个线程老执行 run 方法
        if (ticketNum <= 0) {
            System.out.println("售票结束");
            return;
        }
        try {
            Thread.sleep(50);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        if (--ticketNum == 0) loop = false;
        System.out.println(Thread.currentThread().getName() + "通报,还剩" + ticketNum + "张票");
    }

    @Override
    public void run() {
        while (loop) {
            sell();
        }
    }
}

5.2 同步的原理

六、互斥锁

package com.gyh.thread;

/**
 * @author Gao YongHao
 * @version 1.0
 */
public class Thread9 {
    public static void main(String[] args) {
        SubSellTicket subSellTicket = new SubSellTicket();
        new Thread(subSellTicket).start();
        new Thread(subSellTicket).start();
        new Thread(subSellTicket).start();
    }
}

// 实现接口方式，使用 synchronized 实现线程同步
class SubSellTicket implements Runnable {
    private static int ticketNum = 100;
    private boolean loop = true; // 设置结束条件
    private final Object o = new Object();


    // 解读
    // 1. public synchronized static void m1(){} 锁是加在 SubSellTicket.class 对象上
    // 2. 如果在静态代码中，实现一个同步代码块
    /*
    *   synchronized (SubSellTicket.class){

        }
    *
    * */
    public synchronized static void m1(){

    }
    public static void m2(){
        synchronized (SubSellTicket.class){
            System.out.println("m2");
        }
    }


    // 解读：
    // 1. public synchronized void sell(){} 就是一个同步方法
    // 2. 这时锁是加在 this 对象上
    // 3. 也可以在代码块上写 synchronized ,同步代码块，互斥锁还是在 this 对象
    public /*synchronized*/ void sell() { // 同步方法, 在同一时刻，只能有一个线程老执行 run 方法
        synchronized (/*this*/ o) { // 同步代码块
            if (ticketNum <= 0) {
                System.out.println("售票结束");
                return;
            }
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            if (--ticketNum == 0) loop = false;
            System.out.println(Thread.currentThread().getName() + "通报,还剩" + ticketNum + "张票");
        }
    }

    @Override
    public void run() {
        while (loop) {
            sell();
        }
    }
}

七、死锁

package com.gyh.thread;

/**
 * @author Gao YongHao
 * @version 1.0
 */
public class Thread11 {
    public static void main(String[] args) {
        DeadLockDemo deadLockDemo1 = new DeadLockDemo(true);
        DeadLockDemo deadLockDemo2 = new DeadLockDemo(false);
        deadLockDemo1.start();
        deadLockDemo2.start();

    }
}

// 线程
class DeadLockDemo extends Thread {
    static Object o1 = new Object();// 保证多线程，共享一个对象
    static Object o2 = new Object();
    boolean flag;

    public DeadLockDemo(boolean flag) {
        this.flag = flag;
    }

    @Override
    public void run() {
        // 下面业务逻辑的分析
        // 1. 如果 flag 为 T，线程就会先得到/持有 o1 对象锁，然后尝试去获取 o2 对象锁
        // 2. 如果线程A 得不到 o2 对象锁，就会Blocked
        // 3. 如果flag 为 F,线程B 就会得到/持有 o2 对象锁
        // 4. 如果线程B 得不到 o1 对象锁，就会 Blocked
        if (flag) {
            synchronized (o1) { // 对象互斥锁，下面就是同步代码
                System.out.println(Thread.currentThread().getName() + "进入1");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized (o2) { // 这里获得li对象的监视权
                    System.out.println(Thread.currentThread().getName() + "进入2");
                }
            }
        } else {
            synchronized (o2) {
                System.out.println(Thread.currentThread().getName() + "进入3");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized (o1) { // 这里获得li对象的监视权
                    System.out.println(Thread.currentThread().getName() + "进入4");

                }
            }
        }
    }
}

九、释放锁

八、细节

8.1 互斥锁实现同步的机制

• synchronized方法可以使用this对象的内部锁(互斥锁)来管理当前的方法,同一时刻该互斥锁控制只能有一个线程能够执行synchronized方法,因此该线程能执行代码，而其他线程由于访问不到该互斥锁因此被阻塞,待该互斥锁被释放后再次争夺互斥锁的访问权

8.2 使用继承Thread类的方式创建线程的互斥锁的问题

• 由于继承 Thread 类的创建线程的方式，有多少个线程就会创建多少个对象，因此默认的同步方法对 this 上锁是不同的对象，不能实现同步

package com.gyh.thread;

/**
 * @author Gao YongHao
 * @version 1.0
 */
public class Thread10 {
    public static void main(String[] args) {
        new SubSellTicket1().start();
        new SubSellTicket1().start();
        new SubSellTicket1().start();

    }
}

// 实现接口方式，使用 synchronized 实现线程同步
class SubSellTicket1 extends Thread {
    private static int ticketNum = 100;
    private boolean loop = true; // 设置结束条件

    // 解读：
    // 1. public synchronized void sell(){} 就是一个同步方法
    // 2. 这时锁是加在 this 对象上
    // (但线程启动方式，每一个线程均会创建一个新的对象，这里的this在三个线程中指向各自的对象，因此不能实现同步)
    // 3. 也可以在代码块上写 synchronized ,同步代码块，互斥锁还是在 this 对象
    public /*synchronized*/ void sell() { // 同步方法, 在同一时刻，只能有一个线程老执行 run 方法
        synchronized (this) { // 同步代码块
            if (ticketNum <= 0) {
                System.out.println("售票结束");
                return;
            }
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            if (--ticketNum == 0) loop = false;
            System.out.println(Thread.currentThread().getName() + "通报,还剩" + ticketNum + "张票");
        }
    }

    @Override
    public void run() {
        while (loop) {
            sell();
        }
    }
}