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（小孩儿）是消费者