Java基础 - 12 - 多线程

学习ing小白

已于 2024-08-31 14:09:53 修改

阅读量734

点赞数 26

分类专栏： Java学习文章标签： java 开发语言

于 2024-08-31 13:15:41 首次发布

本文链接：https://blog.csdn.net/qq_50755868/article/details/139862771

版权

Java学习专栏收录该内容

20 篇文章 0 订阅

订阅专栏

线程（Thread）

· 线程是一个程序内部的一条执行流程

· 程序中如果只有一条执行流程，那么这个程序就是单线程的程序

多线程

· 多线程是指从软硬件上实现的多条执行流程的技术（多条线程由CPU负责调度执行）

· 多线程的用途：12306购票、消息通信、购物系统等

一.多线程的创建

如何在程序中创建出多条线程？

Java是通过java.lang.Thread类的对象来代表线程的

多线程的注意事项

· 启动线程必须是调用start方法，不是调用run方法

· 不要把主线程任务放在启动子线程之前

1.1 方式一：继承Thread类

多线程的创建方式一：继承Thread类

方式一优缺点

优点：编码简单

缺点：线程类已经继承Thread，无法继承其他类，不利于功能的拓展

//demo
public class demo {
    //main方法是由一条默认的主线程负责执行
    public static void main(String[] args) {
        //创建MyThread线程类的对象代表一个线程
        Thread t = new MyThread();
        //启动线程（自动执行run方法）
        t.start(); //main线程 t线程

        for (int i = 1; i <= 5; i++) {
            System.out.println("主线程main输出" + i + "次");
        }
    }
}

//MyThread

//让子类继承Thread线程类
public class MyThread extends Thread{
    //必须重写Thread类的run方法

    @Override
    public void run() {
        //描述线程的执行任务
        for (int i = 1; i <= 5; i++) {
            System.out.println("子线程MyThread线程输出" + i + "次");
        }
    }
}

1.2 方式二：实现Runnable接口

多线程的创建方式二：实现Runnable接口

方式二优缺点

优点：任务类只是实现接口，可以继续继承其他类，实现其他接口，扩展性强

缺点：需要多一个Runnable对象

//demo
public class demo {
    //main方法是由一条默认的主线程负责执行
    public static void main(String[] args) {
        //创建任务对象
        Runnable target = new MyRunnable();
        //把任务对象交给一个线程对象处理
        //public Thread(Runnable target)
        new Thread(target).start();

        for (int i = 1; i <= 5; i++) {
            System.out.println("主线程输出 ===>" + i);
        }
    }
}


//MyRunnable
//定义一个任务类，实现Runnable接口
public class MyRunnable implements Runnable {
    //重写runnable的run方法
    @Override
    public void run() {
        //线程要执行的任务
        for (int i = 1; i <= 5; i++) {
            System.out.println("子线程输出 ===>" + i);
        }
    }
}

线程创建方式二的匿名内部类写法

//demo
public class demo {
    //main方法是由一条默认的主线程负责执行
    public static void main(String[] args) throws Exception {
        //直接创建Runnable接口的匿名内部类形式
        Runnable target = new Runnable() {
            @Override
            public void run() {
                for (int i = 1; i <= 5; i++) {
                    System.out.println("子线程1输出 ===>" + i);
                }
            }
        };
        new Thread(target).start();

        //简化形式1
        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 1; i <= 5; i++) {
                    System.out.println("子线程2输出 ===>" + i);
                }
            }
        }).start();

        //简化形式2
        new Thread(() -> {
            for (int i = 1; i <= 5; i++) {
                System.out.println("子线程3输出 ===>" + i);
            }
        }).start();
        
        for (int i = 1; i <= 5; i++) {
            System.out.println("主线程输出 ===>" + i);
        }
    }
}

1.3 方式三：实现Callable接口

多线程的创建方式三：利用Callable接口、FutureTask类来实现

方式三优缺点

优点：线程任务类只是实现接口，可以继续继承类和实现接口，扩展性强；可以在线程执行完毕后去获取线程的执行结果

缺点：编码复杂一些

//demo
public class demo {
    //main方法是由一条默认的主线程负责执行
    public static void main(String[] args) throws Exception {
        //创建一个Callable的对象
        Callable<String> call = new MyCallable(100);
        //把Callable的对象封装成一个FutureTask对象（任务对象）
        //未来任务对象的作用：
          //1.是一个任务对象，实现了Runnable接口
          //2.可以在线程执行完毕后，用未来任务对象调用get方法获取线程执行完毕后的结果
        FutureTask<String> f1 = new FutureTask<>(call);
        //把任务对象交给一个Thread对象
        new Thread(f1).start();

        Callable<String> call2 = new MyCallable(200);
        FutureTask<String> f2 = new FutureTask<>(call2);
        new Thread(f2).start();

        //获取线程执行完毕后返回的结果
        //注意：如果执行到这里，假如上面的线程还没有执行完毕，这里的代码会暂停，等待上面线程长记性完毕后才会获取结果
        String rs = f1.get();
        System.out.println(rs);

        String rs2 = f2.get();
        System.out.println(rs2);
    }
}

//MyCallable
public class MyCallable implements Callable<String> {
    private int n;
    public MyCallable(int n){
        this.n = n;
    }
    //重写call方法
    @Override
    public String call() throws Exception {
        //描述线程的任务，返回线程执行返回后的结果
        //需求：求1-n的和
        int sum = 0;
        for (int i = 0; i <= n; i++) {
            sum += i;
        }
        return "线程求出了1-" +n + "的和是：" + sum;
    }
}

二.Thread的常用方法

//demo
public class demo {
    public static void main(String[] args) {
        Thread t1 = new MyThread("1号线程");
        //t1.setName("1号线程");
        t1.start();
        System.out.println(t1.getName()); //1号线程

        Thread t2 = new MyThread("2号线程");
        //t2.setName("2号线程");
        t2.start();
        System.out.println(t2.getName()); //2号线程

        //主线程对象的名字
        Thread m = Thread.currentThread(); //哪个线程执行它，它就会得到哪个线程对象
        //m.setName("主线程");
        System.out.println(m.getName()); //主线程

        for (int i = 1; i <= 3; i++) {
            System.out.println("main线程输出：" + i);
        }
    }
}

//demo2
public class demo2 {
    public static void main(String[] args) throws Exception {
        for (int i = 0; i <= 5; i++) {
            System.out.println(i);
            //休眠5s
            if(i == 3){
                Thread.sleep(5000);
            }
        }

        //join方法作用：让当前调用这个方法的线程先执行完
        Thread t1 = new MyThread("1号线程");
        t1.start();
        t1.join();

        Thread t2 = new MyThread("2号线程");
        t2.start();
        t2.join();

        Thread t3 = new MyThread("3号线程");
        t3.start();
        t3.join();
    }
}


//MyThread

//让子类继承Thread线程类
public class MyThread extends Thread{

//    private String name;
//
//    public MyThread(String name){
//        this.name = name; //为当前线程设置名字
//    }

    public MyThread(String name){
        super(name); //为当前线程设置名字
    }

    //必须重写Thread类的run方法
    @Override
    public void run() {
        Thread m = Thread.currentThread();
        //描述线程的执行任务
        for (int i = 1; i <= 3; i++) {
            System.out.println("子线程" + m.getName() + "输出：" + i);
        }
    }
}

Thread其他方法的说明

Thread类还提供了如：yield、interrupt、守护线程、线程优先级等线程的控制方法，在开发中很少使用。

三.线程安全

线程安全问题

多个线程，同时操作同一个共享资源的时候，可能会出现业务安全问题

//demo
public class demo {
    public static void main(String[] args) {
        Account account = new Account(100000);

        new MyThread("小明", account).start();
        new MyThread("小红", account).start();

    }
}

//MyThread
public class MyThread extends Thread{
    private Account account;

    public MyThread(){
    }

    public MyThread(String name, Account account) {
        super(name);
        this.account = account;
    }

    @Override
    public void run() {
        //取钱
        account.qukuan(100000);
    }
}

//Account
public class Account {
    private double balance; //余额

    public Account() {
    }

    public Account(double balance) {
        this.balance = balance;
    }

    public void qukuan(double money){
        //谁来取钱?
        String name = Thread.currentThread().getName();

        if(balance >= money){
            balance -= money;
            System.out.println(name + "取款" + money + "成功，账户余额：" + balance);
        }else{
            System.out.println("账户余额不足");
        }
    }

    public double getBalance() {
        return balance;
    }

    public void setBalance(double balance) {
        this.balance = balance;
    }
}

四.线程同步

线程同步

解决线程安全问题的方案

线程同步的思想

让多个线程实现先后依次访问共享资源，这样就解决了安全问题

线程同步的常见方案

加锁：每次只允许一个线程加锁，加锁后才能进入访问，访问完毕后自动解锁，然后其他线程才能再加锁进来

4.1 加锁的三种方式

4.1.1 方式一：同步代码块

作用：把访问共享资源的核心代码给上锁，以此保证线程安全

原理：每次只允许一个线程加锁后进入，执行完毕后自动解锁，其他线程才可以进来执行

同步锁的注意事项

对于当前同时执行的线程来说，同步锁必须是同一把（同一个对象），否则会出bug

——锁对象随便选择一个唯一的对象好不好？

——不好，会影响其他无关线程的执行

锁对象的使用规范

建议使用共享资源作为锁对象，对于实例方法建议使用this作为锁对象，对于静态方法建议使用字节码（类名.class）对象作为锁对象

public class Account {
    private double balance; //余额

    public Account() {
    }

    public Account(double balance) {
        this.balance = balance;
    }

    //多线程调用静态方法
    //建议用类名.class作为锁
    public static void test(){
        synchronized (Account.class){

        }
    }

    public void qukuan(double money){
        //谁来取钱?
        String name = Thread.currentThread().getName();
        //快捷键 CTRL+ALT+T
        //多线程调用实例方法
        //实例方法用this作为锁，this正好代表共享资源
        synchronized (this) {
            if(balance >= money){
                balance -= money;
                System.out.println(name + "取款" + money + "成功，账户余额：" + balance);
            }else{
                System.out.println(name + "取款失败，账户余额不足");
            }
        }
    }

    public double getBalance() {
        return balance;
    }

    public void setBalance(double balance) {
        this.balance = balance;
    }
}

4.1.2 方式二：同步方法

作用：把访问共享资源的核心方法给上锁，以此保证线程安全

原理：每次只允许一个线程加锁后进入，执行完毕后自动解锁，其他线程才可以进来执行

同步方法底层原理

同步方法起始底层也是有隐式锁对象的，只是锁的范围是整个方法代码

如果方法是实例方法，同步方法默认用this作为锁对象

如果方法是静态方法，同步方法默认用类名.class作为锁对象

    //同步方法
    public synchronized void qukuan(double money){
        //谁来取钱?
        String name = Thread.currentThread().getName();
        //快捷键 CTRL+ALT+T
        //多线程调用实例方法
        //实例方法用this作为锁，this正好代表共享资源
        if(balance >= money){
            balance -= money;
            System.out.println(name + "取款" + money + "成功，账户余额：" + balance);
        }else{
            System.out.println(name + "取款失败，账户余额不足");
        }
    }

是同步代码块好一点还是同步方法好一点？

范围上：同步代码块锁的范围更小，同步方法锁的范围更大

可读性：同步方法更好

4.1.3 方式三：Lock锁

Lock锁是JDK5开始提供的一个新的锁定操作，通过它可以创建出锁对象进行加锁和解锁，更灵活、更方便、更强大

Lock是接口，不能直接实例化，可以采用它的实现类ReentrantLock来构建Lock锁对象

public class Account {
    private double balance; //余额
    //创建一个锁对象
    private final Lock lk = new ReentrantLock();

    public Account() {
    }

    public Account(double balance) {
        this.balance = balance;
    }

    public void qukuan(double money){
        //谁来取钱?
        String name = Thread.currentThread().getName();

        lk.lock(); //加锁
        try {
            if(balance >= money){
                balance -= money;
                System.out.println(name + "取款" + money + "成功，账户余额：" + balance);
            }else{
                System.out.println(name + "取款失败，账户余额不足");
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lk.unlock(); //解锁
        }
    }

    public double getBalance() {
        return balance;
    }

    public void setBalance(double balance) {
        this.balance = balance;
    }
}

五.线程通信

当多个线程共同操作共享的资源时，线程间通过某种方式互相告知自己的状态，以相互协调，并避免无效的资源争夺

线程通信的常见模型（生产者与消费者模型）

生产者线程负责生产数据

消费者线程负责消费生产者生产的数据

注意：生产者生产完数据应该等待自己，通知消费者消费；消费者消费完数据也应该等待自己，再通知生产者生产

注意：上述方法应该使用当前同步锁对象进行调用

//demo
public class demo {
    public static void main(String[] args) {
        //创建一个桌子类
        Table t = new Table();

        //创建三个生产者线程（3个厨师）
        new Thread(new Runnable() {
            @Override
            public void run() {
                while (true) {
                    t.put();
                }
            }
        }, "厨师A").start();

        new Thread(() -> {
            while (true) {
                t.put();
            }
        }, "厨师B").start();

        new Thread(() -> {
            while (true) {
                t.put();
            }
        }, "厨师C").start();

        //创建两个消费者线程（3个顾客）
        new Thread(() -> {
            while (true) {
                t.get();
            }
        }, "顾客1").start();

        new Thread(() -> {
            while (true) {
                t.get();
            }
        }, "顾客2").start();
    }
}


//Table
public class Table {
    private List<String> list = new ArrayList<>();

    //放一个包子的方法（厨师A 厨师B 厨师C）
    public synchronized void put() {
        try {
            String name = Thread.currentThread().getName();
            //判断桌子上是否有包子
            if(list.size() == 0){ //桌子上没包子
                list.add(name + "生产了一个包子");
                System.out.println(name + "生产了一个包子，放到桌子上");
                Thread.sleep(2000);

                //唤醒别人，等待自己
                this.notifyAll();
                this.wait();
            }else{ //桌子上有包子，厨师不用做了
                //唤醒别人，等待自己
                this.notifyAll();
                this.wait();
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    //拿一个包子的方法（顾客1 顾客2）
    public synchronized void get() {
        try {
            String name = Thread.currentThread().getName();
            //判断桌子上是否有包子
            if(list.size() != 0){ //桌子上有包子
                list.remove(0);
                //list.clear();
                System.out.println(name + "消费了一个桌子上的包子");
                Thread.sleep(2000);

                //唤醒别人，等待自己
                this.notifyAll();
                this.wait();
            }else{ //桌子上没有包子，顾客不用吃包子
                //唤醒别人，等待自己
                this.notifyAll();
                this.wait();
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

六.线程池

线程池是一个可以复用线程的技术

不使用线程池的问题

用户每发起一个请求，后台就需要创建一个新线程来处理，下次新任务来了肯定又要创建新线程处理的，而创建新线程的开销是很大的，并且请求过多时，肯定会产生大量的线程出来，这样会严重影响系统的性能

线程池的工作原理

6.1 创建线程池

JDK5.0起提供了代表线程池的接口：ExecutorService

如何得到线程池对象？

方式一：使用ExecutorService的实现类ThreadPoolExecutor自创建一个线程池对象

方式二：使用Executors（线程池的工具类）调用方法返回不同特点的线程池对象

ThreadPoolExecutor构造器

public ThreadPoolExecutor(int corePoolSize,

                                             int maximumPoolSize,

                                             long keepAliveTime,

TimeUnit unit,

                                              BlockingQueue<Runnable> workQueue,

                                              ThreadFactory threadFactory,

                                              RejectedExecutionHandler handler)

参数一：corePoolSize：指定线程池的核心线程的数量

参数二：maximumPoolSize：指定线程池的最大线程数量

参数三：keepAliveTime：指定临时线程的存活时间

参数四：unit：指定临时线程存活的时间单位（秒、分、时、天）

参数五：workQueue：指定线程池的任务队列

参数六：threadFactory：指定线程池的线程工厂

参数七：handler：指定线程池的任务拒绝策略（线程都在忙，任务队列也满了的时候，新任务来了该怎么处理）

线程池的注意事项

1.临时线程什么时候创建？

新任务提交时发现核心线程都在忙，任务队列也满了，并且还可以创建临时线程，此时才会创建临时线程

2.什么时候会开始拒绝新任务？

核心线程和临时线程都在忙，任务队列也满了，新的任务过来的时候才会开始拒绝任务

6.3 线程池处理Runnable任务

新任务拒绝策略

//demo
public class demo {
    public static void main(String[] args) {
        //1.通过ThreadPoolExcutor创建一个线程池对象
//        public ThreadPoolExecutor(int corePoolSize,
//                                  int maximumPoolSize,
//                                  long keepAliveTime,
//                                  TimeUnit unit,
//                                  BlockingQueue<Runnable> workQueue,
//                                  ThreadFactory threadFactory,
//                                  RejectedExecutionHandler handler)
//        new ThreadPoolExecutor(3,5,8,
//                TimeUnit.SECONDS,new LinkedBlockingQueue<>(),Executors.defaultThreadFactory(),
//                new ThreadPoolExecutor.AbortPolicy());
        ExecutorService pool = new ThreadPoolExecutor(3,5,8,
                TimeUnit.SECONDS,new ArrayBlockingQueue<>(4),Executors.defaultThreadFactory(),
                new ThreadPoolExecutor.AbortPolicy());

        Runnable target = new MyRunnable();
        pool.execute(target); //线程池会自动创建一个新线程，自动处理这个任务，自动执行的！
        pool.execute(target); //线程池会自动创建一个新线程，自动处理这个任务，自动执行的！
        pool.execute(target); //线程池会自动创建一个新线程，自动处理这个任务，自动执行的！
        pool.execute(target);
        pool.execute(target);
        pool.execute(target);
        pool.execute(target);
        //临时线程的创建时机
        pool.execute(target);
        pool.execute(target);
        //到了新任务的拒绝时机
        pool.execute(target);

        //pool.shutdown(); //等着线程池的任务全部执行完毕后，再关闭线程池
        //pool.shutdownNow(); //立即关闭线程池！不管任务是否执行完毕
    }
}

//MyRunnable
public class MyRunnable implements Runnable{
    @Override
    public void run() {
        //任务是做什么的？
        System.out.println(Thread.currentThread().getName()+" ===> 输出666");
        try{
            Thread.sleep(Integer.MAX_VALUE);
        }catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

6.4 线程池处理Callable任务

//demo
public class demo {
    public static void main(String[] args) throws Exception {
        //1.通过ThreadPoolExcutor创建一个线程池对象
        ExecutorService pool = new ThreadPoolExecutor(3,5,8,
                TimeUnit.SECONDS,new ArrayBlockingQueue<>(4),Executors.defaultThreadFactory(),
                new ThreadPoolExecutor.AbortPolicy());

        //2.使用线程处理Callable任务
        Future<String> f1 = pool.submit(new MyCallable(100));
        Future<String> f2 = pool.submit(new MyCallable(200));
        Future<String> f3 = pool.submit(new MyCallable(300));
        Future<String> f4 = pool.submit(new MyCallable(400));

        System.out.println(f1.get());
        System.out.println(f2.get());
        System.out.println(f3.get());
        System.out.println(f4.get());
    }
}

//MyCallable
public class MyCallable implements Callable<String> {

    private int n;
    public MyCallable(int n){
        this.n = n;
    }

    @Override
    public String call() throws Exception {

        int sum = 0;
        for (int i = 1; i <= n; i++) {
            sum += i;
        }
        return Thread.currentThread().getName() + "线程求出了1-" + n + "的和是：" + sum;
    }
}

6.5 Executors工具类实现线程池

Executors

是一个线程池的工具类，提供了很多静态方法用于返回不同特点的线程池对象

注意：这些方法的底层，都是通过线程池的实现类ThreadPoolExecutor创建的线程池对象

//demo
public class demo {
    public static void main(String[] args) throws Exception {
        //1.通过ThreadPoolExcutor创建一个线程池对象
//        ExecutorService pool = new ThreadPoolExecutor(3,5,8,
//                TimeUnit.SECONDS,new ArrayBlockingQueue<>(4),Executors.defaultThreadFactory(),
//                new ThreadPoolExecutor.AbortPolicy());

        //1.通过Executors创建一个线程池对象
        ExecutorService pool = Executors.newFixedThreadPool(3);

        //核心线程数量到底配置多少？
        //CPU核数：电脑的任务管理器（快捷键：ctrl+shift+esc）-性能-逻辑处理器数量
        //计算密集型的任务：核心线程数量 = CPU的核数 + 1
        //IO密集型的任务：核心线程数量 = CPU的核数 * 2

        //2.使用线程处理Callable任务
        Future<String> f1 = pool.submit(new MyCallable(100));
        Future<String> f2 = pool.submit(new MyCallable(200));
        Future<String> f3 = pool.submit(new MyCallable(300));
        Future<String> f4 = pool.submit(new MyCallable(400));

        System.out.println(f1.get());
        System.out.println(f2.get());
        System.out.println(f3.get());
        System.out.println(f4.get());
    }
}

//MyCallable
public class MyCallable implements Callable<String> {

    private int n;
    public MyCallable(int n){
        this.n = n;
    }

    @Override
    public String call() throws Exception {

        int sum = 0;
        for (int i = 1; i <= n; i++) {
            sum += i;
        }
        return Thread.currentThread().getName() + "线程求出了1-" + n + "的和是：" + sum;
    }
}

Executors使用可能存在的陷阱

大型并发系统环境中使用Executors如果不注意可能会出现系统风险

七.并发、并行

进程

· 正在运行的程序（软件）就是一个独立的进程

· 线程是属于进程的，一个进程中可以同时运行很多个线程

· 进程中的多线程其实是并发和并行执行的

并发的含义

进程中的线程是由CPU负责调度执行的，但CPU能同时处理线程的数量有限，为了保证全部线程都能往前执行，CPU会轮询为系统的每个线程服务，由于CPU切换的速度很快，给我们的感觉这些线程在同时执行，这就是并发。

并行的理解

在同一时刻上，同时有多个线程在被CPU调度执行

八.线程的生命周期

线程的生命周期：线程从生到死的过程中，经历的各种状态及状态转换

Java线程的状态

Java共定义了6种状态，都在Thread类的内部枚举类中

public class Thread{
    ……
    public enum State {
        NEW,
        RUNNABLE,
        BLOCKED,
        WAITING,
        TIMED_WAITING,
        TERMINATED;
    }
    ……
}

线程的6种状态互相转换

线程的6种状态总结

九.悲观锁和乐观锁

悲观锁和乐观锁
悲观锁：一上来就加锁，每次只能一个线程进入访问完毕后，再解锁。

线程安全，但性能较差

乐观锁：一开始不上锁，认为是没有问题的，等要出现线程安全问题的时候才开始控制。

线程安全，性能较好

public class demo {
    public static void main(String[] args) {
        //悲观锁和乐观锁
        //悲观锁：一上来就加锁，每次只能一个线程进入访问完毕后，再解锁。 线程安全，但性能较差
        //乐观锁：一开始不上锁，认为是没有问题的，等要出现线程安全问题的时候才开始控制。 线程安全，性能较好

        //需求：1个变量，100个线程。每个线程对其加100次

        Runnable target = new MyRunnable();
        for (int i = 1; i <= 100; i++) {
            new Thread(target).start();
        }
    }
}

//悲观锁
public class MyRunnable implements Runnable{
    private int num; //记录浏览人次
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            synchronized (this){
                System.out.println(Thread.currentThread().getName() + " num ==>" + (++num));
            }
        }
    }
}

//乐观锁
public class MyRunnable implements Runnable{
    //整数修改的乐观锁：原子类实现的
    private AtomicInteger count = new AtomicInteger();

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName() + " num ==>" + count.incrementAndGet());
        }
    }
}

十.案例

//demo
public class demo {
    public static void main(String[] args) throws InterruptedException {
        List<String> gifts = new ArrayList<>();
        String[] names = {"化妆品","鲜花","包包","皮带","鞋子","衬衣"};
        Random r = new Random();

        for (int i = 1; i <= 100; i++) {
            gifts.add(i + "号礼物：" + names[r.nextInt(names.length)]);
        }
        System.out.println(gifts);

        //定义线程类，创建线程对象，去集合中拿礼物
        SendThread xm = new SendThread(gifts,"小明");
        xm.start();
        SendThread xh = new SendThread(gifts,"小红");
        xh.start();

        xm.join();
        xh.join();

        System.out.println(xm.getCount());
        System.out.println(xh.getCount());
    }
}

//SendThread
public class SendThread extends Thread{
    private List<String> gifts;
    private int count;

    public SendThread(List<String> gifts, String name){
        super(name);
        this.gifts = gifts;
    }

    @Override
    public void run() {
        String name = Thread.currentThread().getName();
        Random r = new Random();
        while(true){
            synchronized (gifts){
                if(gifts.size()<10){
                    break;
                }
                String rs = gifts.remove(r.nextInt(gifts.size()));
                System.out.println(name + "发出了" + rs);
                count++;
            }
        }
    }

    public int getCount() {
        return count;
    }

    public void setCount(int count) {
        this.count = count;
    }
}