Java基础篇---多线程

内容导航：

1、多线程的实现方式

2、线程安全问题

3、线程间通信

4、生产者消费者模式

第一部分多线程的实现方式

在java中多线程实现方式有2种

一、自定义一个类A，继承Thread类

public class ThreadA extends Thread {
    public void run(){
       
        }
    }

}

此时ThreadA是一个线程类，在ThreadA中重写Thread类中的run方法

调用方式如下

ThreadA A = new ThreadA();
A.start();

二、自定义一个类B，实现Runable接口

public class ThreadB implements Runnable {
    public void run() {
       
    }
}

此时ThreadB不是一个线程类，在ThreadB中重写Thread类中的run方法

ThreadB b = new ThreadB();
Thread t1 = new Thread(b);
t1.start();

需要在初始化Thread的时候，把Runnable接口的实现类的对象b作为参数传入

---

第二部分是线程安全问题

线程安全问题产生的场景：

public class SaleTickets implements Runnable {

    private int num = 100;   //表示100张火车票   这是共享资源

    //买100张火车票
    public void run() {
        for (int i = 0; i < num; i++) {
            if (num > 0) {
                System.out.println(Thread.currentThread().getName() + "买了编号为" + num + "的火车票");
                num--;
                try {
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                }
            }
        }
    }
}

SaleTickets st=new SaleTickets ();
Thread tA=new Thread(st);    //用户A
Thread tB=new Thread(st);    //用户B

tA.setName("用户A线程");
tB.setName("用户B线程");

tA.start();
tB.start();
            

进入12306购买火车票的时候，为了解决多个人同时进行抢票问题，需要使用多线程来增加系统效率，假如票共有100张，用户A和用户B同时进行买票，如果是单线程，每次用户买票的时候，首先会打印用户买到了哪张票，然后票的总数num减1。

但是由于是多线程，多线程有一个特性就是线程的执行顺序由cpu来分配，所以执行顺序是不确定的，假如用户A执行SaleTickets方法中的第10行的时候，会打印出用户A线程买了编号为100的火车票，此时用户B线程也开始执行SaleTickets方法，用户B也会打印出用户B线程买了编号为100的火车票

这种结果不是合理的，所以就引发线程安全问题

解决线程安全问题的方式有2种

1、同步代码块

public class SaleTickets implements Runnable {

    private int num = 100;   //表示100张火车票   这是共享资源

    //买100张火车票
    public void run() {
        for (int i = 0; i < num; i++) {
            synchronized (this){
                if (num > 0) {
            　　　　System.out.println(Thread.currentThread().getName() + "买了编号为" + num + "的火车票");
            　　　　num--;
            　　　　try {
                　　　　Thread.sleep(500);
            　　　　} catch (InterruptedException e) {
            　　　　}
        　　　　　}
             }   
        }
    }
}            

2、同步方法

public class SaleTickets implements Runnable {

    private int num = 100;   //表示100张火车票   这是共享资源

    public synchronized  void saleOne(){
        if (num > 0) {
            System.out.println(Thread.currentThread().getName() + "买了编号为" + num + "的火车票");
            num--;
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
            }
        }
    }

    //买100张火车票
    public void run() {
        for (int i = 0; i < 10; i++) {
            saleOne();
        }
    }
}

此时同步方法中的synchronized的锁默认为this

---

第三部分是线程间通信

线程间的通信机制为等待唤醒机制，多个线程通信的前提是共用同一把锁 

wait（long  timeout） 当前线程释放锁，并等待timeout毫秒

notify 唤醒持有同一锁的某个线程

1、定义一个静态object对象，作为线程间通信的锁

public class MyLock {
    public static Object obj = new Object();
}

2、定义线程A

//定义一个线程类  输出1
public class ThreadA extends Thread {

    public void run(){
        for(int j=0;j<10;j++){
            synchronized (MyLock.obj) {
                System.out.println(1);
                MyLock.obj.notify();
                try {
                    MyLock.obj.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }

}

3、定义线程B

//定义一个线程类   输出2
public class ThreadB extends Thread {

    public void run(){
        for(int j=0;j<10;j++){
            synchronized (MyLock.obj) {
                System.out.println(2);
                MyLock.obj.notify();
                try {
                    MyLock.obj.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }

}

4、定义主函数执行线程A和线程B

public class TestThreadForSignal {
    public static void main(String[] args){
        new ThreadA().start();
        new ThreadB().start();
    }
}

执行结果：交替打印1和2

执行原理：先执行线程A，会被同步代码块synchronized锁住，打印1，然后唤醒共用MyLock.obj锁的线程B，然后线程A进入等待，并释放锁。然后执行线程B，会被同步代码块synchronized锁住，打印2，然后唤醒共用MyLock.obj锁的线程A，然后线程B进入等待，并释放锁。接下来继续执行线程A循环往复.......

---

第四部分是生产者消费者模式

利用线程间通信可以很好的实现生产者消费者模式

因为这个代码跟上面线程通信的代码很类似，这里博主不打算继续码代码了，用文字做一个简要说明

线程A （农夫）  往篮子里放苹果   如果篮子满了（苹果数量=10），线程A wait，如果没满（苹果数量<10），往篮子里放苹果，同时告诉B（小孩儿） notify唤醒

线程B （小孩儿）从篮子里拿苹果吃   如果篮子空了（苹果数量=0），线程B wait   如果篮子里还有苹果（苹果数量>0），从篮子里拿苹果吃   同时告诉A（农夫）notify唤醒

在这个场景里线程A（农夫）是生产者，线程B（小孩儿）是消费者