多线程的基础知识(一)

一：进程和线程的概念

• 进程：是正在运行的程序
  • 是系统进行资源分配和调用的独立单位
  • 每一个进程都有它自己的内存空间和系统资源
• 线程：是进程中的单个顺序控制流，是一条执行路径
  • 单线程：一个进程如果只有一条执行路径，则称为单线程程序（记事本）
  • 多线程：一个进程如果有多条执行路径，则称为多线程程序（360扫描）

单线程例子：记事本

注：记事本就是一个单线程的程序，当我编辑文件后，我打开页面设置，然后反过来想到编辑区来编辑文字可是我怎么点也没用，必须将页面设置窗口给关掉，才可以继续在编辑区编辑文字！

多线程例子：360扫描

注：你会发现不会像记事本一样，每次只能点一个地方，不能同时执行

二：实现多线程的方案

2.1：继承Thread类

一：步骤:
1.定义一个类MyThread继承Thread类
2.在MyThread类中重写run()方法
3.创建MyThread类的对象
4.启动线程

二：两个小问题：
1.为什么要重写run()方法？
答:因为run()是用来封装被线程执行的代码
2.run()方法和start()方法的区别？
答:run()：封装线程执行的代码，直接调用，相当于普通方法的调用,start()：启动线程；然后由JVM调用此线程的run()方法

2.2：实现Runnable接口

一：步骤
1.定义一个类MyRunnable实现Runnable接口
2.在MyRunnable类中重写run()方法
3.创建MyRunnable类的对象
4.创建Thread类的对象，把MyRunnable对象作为构造方法的参数
5.启动线程

二：问题：相比继承Thread类，实现Runnable接口的好处
a.避免了Java单继承的局限性
b.适合多个相同程序的代码去处理同一个资源的情况，把线程和程序的代码、数据有效分离，较好的体现了面向对象的设计思想

三：线程调度的概念

• 线程的调度模型
  • 分时调度模型：所有线程轮流使用 CPU 的使用权，平均分配每个线程占用 CPU 的时间片
  • 抢占式调度模型：l优先让优先级高的线程使用 CPU，如果线程的优先级相同，那么会随机选择一个，优先级高的线程获取的 CPU 时间片相对多一些

注：java使用的是抢占式调度模型

假如计算机只有一个 CPU，那么 CPU 在某一个时刻只能执行一条指令，线程只有得到CPU时间片，也就是使用权，才可以执行指令。所以说多线程程序的执行是有随机性，因为谁抢到CPU的使用权是不一定的

四：线程中的方法

4.1：设置和获取线程中的名称

一：Thread类中设置和获取线程名称的方法
a: void setName(String name)：将此线程的名称更改为等于参数 name
b: String getName()：返回此线程的名称
c: 通过构造方法也可以设置线程名称

二：如何获取main()方法所在的线程名称?
public static Thread currentThread()：返回对当前正在执行的线程对象的引用

4.2：设置和获取线程的优先级

一：Thread类中设置和获取线程优先级的方法
public final int getPriority()：返回此线程的优先级
public final void setPriority(int newPriority)：更改此线程的优先级
注:线程默认优先级是5；线程优先级的范围是：1-10
注:线程优先级高仅仅表示线程获取的CPU时间片的几率高，但是要在次数比较多，或者多次运行的时候才能看到你想要的效果

4.3：线程控制的方法

1.sleep(long millis)：使当前正在执行的线程停留（暂停执行）指定的毫秒数
2.join() 等待这个线程死亡
3.setDaemon(boolean on) 将此线程标记为守护线程，当运行的线程都是守护线程时，Java虚拟机将退出

• join()的例子

/**
 * 争夺皇位之join: 应该是等康熙挂了,四阿哥,八阿哥才去争夺
 * join():等待这个线程死亡,再执行其他的线程
 */
public class ThreadDemo5 {
    public static void main(String[] args) {
        MyThread5 t1 = new MyThread5();
        MyThread5 t2 = new MyThread5();
        MyThread5 t3 = new MyThread5();

        t1.setName("康熙");
        t2.setName("四阿哥");
        t3.setName("八啊哥");

        t1.start();
        try {
            t1.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        t2.start();
        t3.start();
    }
}

class MyThread5 extends Thread{
    @Override
    public void run() {
        for(int i=0; i<100; i++){
            System.out.println(getName()+":"+i);
        }
    }
}

• setDaemon()的例子

/**
 * 桃园三结义之守护线程,坦克大战
 * 例子1: 当刘备挂了之后，关羽和张飞也跟着自杀(死前会挣扎几下)
 * 例子2: 坦克大战中,大王死了，那么小坦克就全部爆炸了!
 * setDaemon():将此线程标记为守护线程，当运行的线程都是守护线程时，Java虚拟机将退出
 */
public class ThreadDemo6 {
    public static void main(String[] args) {
        MyThread6 t1 = new MyThread6();
        MyThread6 t2 = new MyThread6();

        t1.setName("关羽");
        t2.setName("张飞");

        //设置主线程为刘备
        Thread.currentThread().setName("刘备");
        //将t1,t2设置为守护线程！
        t1.setDaemon(true);
        t2.setDaemon(true);

        t1.start();
        t2.start();

        for(int i=0; i<10; i++){
            System.out.println(Thread.currentThread().getName()+":"+i);
        }

    }
}

class MyThread6 extends Thread{
    @Override
    public void run() {
        for(int i=0; i<100; i++){
            System.out.println(getName()+":"+i);
        }
    }
}

五：线程的生命周期

六：线程同步

需求：某电影院目前正在上映国产大片，共有100张票，而它有3个窗口卖票，请设计一个程序模拟该电影院卖票

一：思路：
①：定义一个类SellTicket实现Runnable接口，里面定义一个成员变量：private int tickets = 100;
②：在SellTicket类中重写run()方法实现卖票，代码步骤如下
    A：判断票数大于0，就卖票，并告知是哪个窗口卖的
    B：卖了票之后，总票数要减1
    C：票没有了，也可能有人来问，所以这里用死循环让卖票的动作一直执行
③：定义一个测试类SellTicketDemo，里面有main方法，代码步骤如下
    A：创建SellTicket类的对象
    B：创建三个Thread类的对象，把SellTicket对象作为构造方法的参数，并给出对应的窗口名称
    C：启动线程
    
二：卖票出现的问题
1.相同的票出现了多次
2.出现了负数的票

三：问题原因：
线程执行的随机性导致的

演示代码

public class SellTicketDemo {
    public static void main(String[] args) {
        SellTicket sellTicket = new SellTicket();
        Thread t1 = new Thread(sellTicket,"窗口一");
        Thread t2 = new Thread(sellTicket,"窗口二");
        Thread t3 = new Thread(sellTicket,"窗口三");

        t1.start();
        t2.start();
        t3.start();
    }
}

class SellTicket implements Runnable{

    private int tickets = 100; //票

    @Override
    public void run() {
        while(true){//模拟一直在买票
            if(tickets>0){
                try {
                    Thread.sleep(100);//模拟出票时间
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName()+"正在售出第"+tickets+"张票!");
                tickets--;
            }
        }
    }
}

运行上面的程序，可能会出现两个问题，1.相同的票出现了多次，2.出现了负数票

• 分析相同的票出现了多次

public class ThreadDemo{
    public static void main(String[] args) {
        MyRunnable3 runnable = new MyRunnable3();

        Thread t1 = new Thread(runnable,"窗口1");
        Thread t2 = new Thread(runnable,"窗口2");
        Thread t3 = new Thread(runnable,"窗口3");

        t1.start();
        t2.start();
        t3.start();
    }
}

class MyRunnable implements Runnable{
    private int tickets = 100;
    @Override
    public void run() {
        //分析1:相同的票执行多次
        //tickets = 100
        //t1,t2,t3
        //假设t1线程抢到了cpu的执行权
        while(true){
            if(tickets>0){
                try {
                    //模拟出票时间
                    Thread.sleep(100);
                    //t1线程休息了100毫秒
                    //t2线程抢到了cpu的执行权,t2线程就开始执行,执行到这里的时候,也休眠了100毫秒
                    //t3线程抢到了cpu的执行权,t3线程就开始执行,执行到这里的时候,也休眠了100毫秒
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                //假设线程按照顺序醒过来
                //t1抢到cpu的执行权,在控制台输出：窗口1正在出售第100张票.
                System.out.println(Thread.currentThread().getName()+":正在出售第"+tickets+"张票.");
                //t2抢到了cpu的执行权,在控制台输出：窗口2正在出售第100张票.
                //t3抢到了cpu的执行权,在控制台输出：窗口3正在出售第100张票.
                tickets--;
                //假设这三个线程还是按照顺序，这里就执行了三次-的操作，也就变成了97
            }
        }
    }
}

• 分析出现了负数票

public class ThreadDemo9 {
    public static void main(String[] args) {
        MyRunnable3 runnable = new MyRunnable3();

        Thread t1 = new Thread(runnable,"窗口1");
        Thread t2 = new Thread(runnable,"窗口2");
        Thread t3 = new Thread(runnable,"窗口3");

        t1.start();
        t2.start();
        t3.start();
    }
}

class MyRunnable3 implements Runnable{
    private int tickets = 100;
    
    @Override
    public void run2() {
        //分析2:出现负数票
        //tickets = 1
        //t1,t2,t3
        //假设t1线程抢到了cpu的执行权
        while(true){
            if(tickets>0){
                try {
                    //模拟出票时间
                    Thread.sleep(100);
                    //t1线程休息了100毫秒
                    //t2线程抢到了cpu的执行权,t2线程就开始执行,执行到这里的时候,也休眠了100毫秒
                    //t3线程抢到了cpu的执行权,t3线程就开始执行,执行到这里的时候,也休眠了100毫秒
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                //假设线程按照顺序醒过来
                //t1抢到cpu的执行权,在控制台输出：窗口1正在出售第1张票.
                //假设t1继续拥有cpu的执行权,就会执行tickets--操作,此时tickets=0;
                //t2抢到cpu的执行权,在控制台输出：窗口2正在出售第0张票.
                //假设t2继续拥有cpu的执行权,就会执行tickets--操作,此时tickets=-1;
                //t3抢到cpu的执行权,在控制台输出：窗口3正在出售第-1张票.
                //设t2继续拥有cpu的执行权,就会执行tickets--操作,此时tickets=-2; 因为三个线程都走完了，所以最终tickets是-1，而不是-2
                System.out.println(Thread.currentThread().getName()+":正在出售第"+tickets+"张票.");
                tickets--;
            }
        }
    }
}

注：出现上面那种原因其实都是由于线程的随机性导致的！

6.1：买票案例数据安全问题的解决

• 为什么出现问题?(这也是我们判断多线程程序是否会有数据安全问题的标准)

1.是否是多线程环境
2.是否有共享数据
3.是否有多条语句操作共享数据

• 如何解决多线程安全问题呢?

基本思想：让程序没有安全问题的环境

• 怎么实现呢?

把多条语句操作共享数据的代码给锁起来，让任意时刻只能有一个线程执行即可,Java提供了同步代码块的方式来解决

6.2：同步代码块

锁多条语句操作共享数据，可以使用同步代码块实现
格式：
synchronized(任意对象) { 
      多条语句操作共享数据的代码 
 }
synchronized(任意对象)：就相当于给代码加锁了，任意对象就可以看成是一把锁

同步的好处和弊端	
好处：解决了多线程的数据安全问题
弊端：当线程很多时，因为每个线程都会去判断同步上的锁，这是很耗费资源的，无形中会降低程序的运行效率

• 将上面买票的程序加上Synchronized关键字，就不会出现线程安全问题了！

class SellTicket implements Runnable{

    private int tickets = 100; //票
	private Object obj = new Object();
    @Override
    public void run() {
        while(true){//模拟一直在买票
            synchronized (obj){//注意：必须是同一把锁，不能在这里new Object();这样就是不同的锁
                if(tickets>0){
                    try {
                        Thread.sleep(100);//模拟出票时间
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName()+"正在售出第"+tickets+"张票!");
                    tickets--;
                }
            }
        }
    }
}

6.3：同步方法

1.同步方法：就是把synchronized关键字加到方法上
2.格式：
	修饰符 synchronized 返回值类型 方法名(方法参数) {    }
3.同步方法的锁对象是什么呢?
	this

• 证明同步方法的锁对象是this

class  MyRunnable implements Runnable{
    private int tickets = 100;
    private Object obj = new Object();
    int count = 0;

    @Override
    public void run() {
        while(true){
           if(count%2 == 0){
               synchronized (obj){
                   if(tickets>0){
                       try {
                           Thread.sleep(100);
                       } catch (InterruptedException e) {
                           e.printStackTrace();
                       }
                       System.out.println(Thread.currentThread().getName()+":正在出售第"+tickets+"张票.");
                       tickets--;
                   }
               }
           }else{
               sellTickets();
           }

           count++;
        }
    }

    private synchronized void sellTickets() {
        if(tickets>0){
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+":正在出售第"+tickets+"张票.");
            tickets--;
        }
    }
}

注：上面的程序虽然看起来加了Synchronized的关键字但还是会出现数据安全问题，原因是锁拿的不是同一把！！if代码块中是以obj作为锁对象，而else代码块中是一个同步方法，而同步方法的锁应该是一个this对象，所以两个锁不一致，为了证明同步方法的锁是this，如果上面if代码块的锁换成this对象可以保证数据安全问题，那么就可以证明同步方法的锁对象是this !!!

6.4：同步静态方法

1.同步静态方法：就是把synchronized关键字加到静态方法上
2.格式：
	修饰符 static synchronized 返回值类型 方法名(方法参数) {    }
3.同步静态方法的锁对象是什么呢?
	类名.class

• 证明同步静态方法的锁对象是类.class

class  MyRunnable implements Runnable{
    private static int tickets = 100;
    private Object obj = new Object();
    int count = 0;

    @Override
    public void run() {
        while(true){
           if(count%2 == 0){
               synchronized (this){
                   if(tickets>0){
                       try {
                           Thread.sleep(100);
                       } catch (InterruptedException e) {
                           e.printStackTrace();
                       }
                       System.out.println(Thread.currentThread().getName()+":正在出售第"+tickets+"张票.");
                       tickets--;
                   }
               }
           }else{
               sellTickets();
           }
           count++;
        }
    }

    private static synchronized void sellTickets() {
        if(tickets>0){
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+":正在出售第"+tickets+"张票.");
            tickets--;
        }
    }
}

注：上面代码也会出现数据安全问题，原因也是两把锁不一致，if代码块中使用的是this对象作为锁，而else代码块中，是一个静态同步方法使用的是类.class作为锁，为了证明静态同步方法使用的是类.class作为锁
如果将if代码块中的锁改为MyRunnable.class，程序就没有出现数据安全问题，就可以验证静态同步方法使用的是类.class作为锁

注：java类可能有很多个对象，但只有一个Class对象

6.5：线程安全的类

线程安全的类: 看源码就知道是不是线程安全的，是线程安全的都被synchronized关键字给修饰了
StringBuffer -> StringBuilder
Vector -> List
Hashtable -> HashMap

6.6：Lock锁

注：如果说Synchronized是自动挡，那么Lock就是手动挡了

1.虽然我们可以理解同步代码块和同步方法的锁对象问题，但是我们并没有直接看到在哪里加上了锁，在哪里释放了锁，为了更清晰的表达如何加锁和释放锁，JDK5以后提供了一个新的锁对象Lock

2.Lock实现提供比使用synchronized方法和语句可以获得更广泛的锁定操作
Lock中提供了获得锁和释放锁的方法
void lock()：获得锁
void unlock()：释放锁

3.Lock是接口不能直接实例化，这里采用它的实现类ReentrantLock来实例化
ReentrantLock()：创建一个ReentrantLock的实例

class MyRunnable6 implements  Runnable{
    private int tickets = 100;
    private Lock lock = new ReentrantLock(); //可重入锁!
    @Override
    public void run() {
        while(true){
            try {
                lock.lock(); //加锁
                if(tickets>0){
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName()+":当前正售出第"+tickets+"张票！");
                    tickets--;
                }
            }finally {
                lock.unlock(); //释放锁
            }
        }
    }
}

七：生产者和消费者

生产者消费者模式是一个十分经典的多线程协作的模式,实际上主要是包含了两类线程：
1.一类是生产者线程用于生产数据
2.一类是消费者线程用于消费数据
为了解耦生产者和消费者的关系，通常会采用共享的数据区域，就像是一个仓库
1.生产者生产数据之后直接放置在共享数据区中，并不需要关心消费者的行为
2.消费者只需要从共享数据区中去获取数据，并不需要关心生产者的行为
生产者 --> 共享数据区域 <-- 消费者

例子：这其实很像今年疫情期间在小区点外卖的场景，在疫情期间，为了避免和外卖人员接触，
通常外卖人员(生产者)会将外卖放到一个指定的区域(共享数据区域)，然后我们（消费者）到指定的区域拿外卖即可。

为了体现生产和消费过程中的等待和唤醒，Java就提供了几个方法供我们使用，这几个方法在Object类中
1.void wait():导致当前线程等待，直到另一个线程调用该对象的 notify()方法或 notifyAll()方法
2.void notify()：唤醒正在等待对象监视器的单个线程
3.void notifyAll()：唤醒正在等待对象监视器的所有线程 

• 例子

/**
 * 生产者消费者案例中包含的类：
 * 奶箱类(Box)：定义一个成员变量，表示第x瓶奶，提供存储牛奶和获取牛奶的操作
 * 生产者类(Producer)：实现Runnable接口，重写run()方法，调用存储牛奶的操作
 * 消费者类(Customer)：实现Runnable接口，重写run()方法，调用获取牛奶的操作
 * 测试类(BoxDemo)：里面有main方法，main方法中的代码步骤如下
 *      1.创建奶箱对象，这是共享数据区域
 *      2.创建生产者对象，把奶箱对象作为构造方法参数传递，因为在这个类中要调用存储牛奶的操作
 *      3.创建消费者对象，把奶箱对象作为构造方法参数传递，因为在这个类中要调用获取牛奶的操作
 *      4.创建2个线程对象，分别把生产者对象和消费者对象作为构造方法参数传递
 *      5.启动线程
 *
 *
 *      监视器:就是锁对象,所以就是提示wait()和notify()应该在同步中使用!, 所以应该将put/get方法加上synchronized关键字!
 *      Exception in thread "Thread-1" Exception in thread "Thread-0" java.lang.IllegalMonitorStateException
 *
 *      终于相达到的效果是，送奶工放牛奶箱一瓶我就拿一瓶!
 */
public class ThreadDemo13 {
    public static void main(String[] args) {
        Box box = new Box();
        Producer producer = new Producer(box);
        Customer customer = new Customer(box);

        Thread t1 = new Thread(producer);
        Thread t2 = new Thread(customer);

        t1.start();
        t2.start();
    }
}

class Box{
    //定义一个成员变量，表示第x瓶奶
    private int milk;
    //定义一个成员变量，表示奶箱的状态
    private boolean state = false;

    //存储牛奶
    public synchronized void put(int milk){
        //如果奶箱中有，就等待
        if(state){
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        //如果奶箱中没有，这里就生产
        this.milk = milk;
        System.out.println("送奶工将第"+this.milk+"瓶奶放入奶箱");

        //生产完了，应该修改奶香的状态为true
        state = true;

        //唤醒其他等待的线程
        notifyAll();
    }

    //获取牛奶
    public synchronized void get(){
        //如果奶箱中没有，我就等待
        if(!state){
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        //如果奶箱中有,我就获取
        System.out.println("用户拿到"+this.milk+"瓶奶");

        //消费完了，应该修改奶香的状态为false
        state = false;

        //唤醒其他等待的线程
        notifyAll();
    }
}

class Producer implements Runnable{

    private Box box;

    public Producer(Box box){
        this.box = box;
    }

    @Override
    public void run() {
        for(int i=1; i<=5; i++){
            box.put(i);
        }
    }
}

class Customer implements Runnable{
    private Box box;

    public Customer(Box box){
        this.box = box;
    }

    @Override
    public void run() {
        while(true){
            box.get();
        }
    }
}

来自：虽然帅，但是菜的cxy