多线程的学习笔记(票数超卖的解决案例)

Thread

Thread类本质上是实现了Runnable接口的一个实例,代表一个线程的实例
启动线程的唯一方法就是通过Thread类的start()实例方法
start()方法是一native方法,它将通知底层操作系统,.最终由操作系统启动一个新线程,操作系统将执行run()
这种方式实现的多线程很简单,通过自己的类直接extends Thread,并重写run()方法,就可以自动启动新线程并执行自己定义的run()方法
模拟开启多个线程,每个线程调用run()方法.

通过买票来进行总结：

package com.tude.demo16.thread;

/**
 * Thread() 分配新的Thread对象
 * Thread(String name) 分配新的Thread对象
 * Thread(Runnable target) 分配新的Thread对象
 * Thread(Runnable target,String name) 分配新的Thread对象
 *
 * 常用方法
 *static Thread currentThread( )
 * 返回对当前正在执行的线程对象的引用
 * long getId()
 * 返回该线程的标识
 * String getName()
 * 返回该线程的名称
 * void run()
 * 如果该线程是使用独立的 Runnable 运行对象构造的，则调用该 Runnable 对象的 run 方法
 * static void sleep(long millions)
 * 在指定的毫秒数内让当前正在执行的线程休眠(暂停执行)
 * void start()
 * 使该线程开始执行:Java虚拟机调用该线程的run()
 *
 */
public class TestThread1 {
    public static void main(String[] args) {
        //创建对象
        MyThread t1 = new MyThread();
        MyThread t2 = new MyThread();
        MyThread t3 = new MyThread();

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

    }
}

class MyThread extends Thread {

    //定义票数
    static int ticket = 100;

    @Override
    public void run() {
        //模拟一直抢票
        while (true) {
            if (ticket > 0) {

                try {
                    //先睡10毫秒
                    sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                
            }
            //假设票抢完了
            if (ticket <= 0)
                break;
            //开始抢票
            System.out.println(getName() + "=" + ticket--);

        }
    }
}

运行结果

通过上面的运行结果，发现线程进行抢票的时候，容易抢到重复的票。

两种实现方式的比较
继承Thread类
优点: 编写简单,如果需要访问当前线程,无需使用Thread.currentThread()方法,直接使用this即可获得当前线程
缺点: 自定义的线程类已继承了Thread类,所以后续无法再继承其他的类
实现Runnable接口
优点: 自定义的线程类只是实现了Runnable接口或Callable接口,后续还可以继承其他类,在这种方式下,多个线程可以共享同一个target对象,所以非常适合多个相同线程来处理同一份资源的情况,从而可以将CPU、代码、还有数据分开(解耦),形成清晰的模型,较好地体现了面向对象的思想
缺点: 编程稍微复杂,如想访问当前线程,则需使用Thread.currentThread()方法

为解决重复抢票的问题，我们可以添加同步锁synchronized

同步效果的使用有两个前提:

• 前提1：同步需要两个或者两个以上的线程(单线程无需考虑多线程安全问题)
• 前提2：多个线程间必须使用同一个锁(我上锁后其他人也能看到这个锁,不然我的锁锁不住其他人,就没有了上锁的效果)

注意，因为要多个线程，所以我们要使用Runnable接口

import java.util.concurrent.locks.ReentrantReadWriteLock;

public class TestRunnable {
    public static void main(String[] args) {

        //创建实体类对象
        TicketRunnable runnable = new TicketRunnable();
        Thread t1 = new Thread(runnable);
        Thread t2 = new Thread(runnable);
        Thread t3 = new Thread(runnable);
        Thread t4 = new Thread(runnable);

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

    }
}

class TicketRunnable implements Runnable {

    Object o = new Object();
    //定义票数
    static int ticket = 100;

    static ReentrantReadWriteLock lock = new ReentrantReadWriteLock(true);
    @Override
    public void run() {
        //开启无线卖票
        while(true){

            //在操作共享资源前上锁
            lock.writeLock().lock();
            try {
                if (ticket > 0) {
                    //先睡10毫秒
                    try {
                        Thread.sleep(10);
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                }
                if (ticket <= 0)
                    break;
                System.out.println(Thread.currentThread().getName() + "=" + ticket--);
            }catch (Exception e){
                e.printStackTrace();
            }finally {
                //finally()中释放锁，注意一定要手动释放，防止死锁，否则就独占报错
                lock.writeLock().unlock();
            }
        }
    }
}