线程状态与线程同步

最新推荐文章于 2024-03-11 16:32:38 发布
最新推荐文章于 2024-03-11 16:32:38 发布
阅读量216 收藏 1
点赞数
文章标签： 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/page_4esopxo/article/details/110493800
版权

一、线程的状态

  1. 创建（new）状态：准备好了一个多线程的对象，即执行了new Thread()；创建完成后就需要为线程分配内存
  2. 就绪（runnable）状态：调用start()方法，线程立即进入就绪状态，但不意味着立即调度执行，而是等待CPU进行调度。
  3. 运行（running）状态：真正开始执行run()方法
  4. 阻塞（blocked）状态：暂时停止执行线程，将线程挂起（sleep()、wait()、join()、没有获取到锁都会使线程阻塞），可能将资源交给其它线程使用，阻塞事件解除后，重新进入就绪状态，等待cpu调度执行。
  5. 死亡（terminated）状态：线程销毁(正常执行完毕、发生异常或者被打断interrupt()都会导致线程终止)，一旦线程进入死亡状态，就不能能再次启动。



    | 方法 | 说明 |
    | ------------------------------ | :----------------------------------------- |
    | setPriority(int newPriority) | 更改线程的优先级 |
    | static void sleep(long millis) | 在指定的毫秒数内让当前正在执行的线程休眠 |
    | void join() | 等待该线程终止 |
    | static void yield() | 暂停当前正在执行的线程对象，并执行其他线程 |
    | viod interrupt() | 中断线程，别用这个方法 |
    | boolean isAlive() | 测试线程是否处于活动状态 |

1. 停止线程

  • 不推荐使用JDK提供的stop()、destroy()方法（已过时）
  • 推荐线程自己停止下来
  • 建议使用一个标志位进行终止变量，当flag=false，则终止线程运行
public class ThreadStop implements Runnable{
    /*线程中定义线程体使用的标识*/
    private boolean flag = true;
    @Override
    public void run() {
        /*线程体使用该标识*/
        while (flag) {
            System.out.println("run...Thread");
        }
    }
    /*对外提供方法改变标识*/
    public void stop() {
        this.flag = false;
    }
}

public class Stop extends ThreadStop{
    public static void main(String[] args) {
        final ThreadStop threadStop = new ThreadStop();
        new Thread(threadStop).start();
        int a = 10;
        for (int i = 0; i < a; i++) {
            System.out.println("main:" + i);
            if (i == 5) {
                /*调用stop方法切换标识，让线程停止*/
                threadStop.stop();
                System.out.println("线程停止了...");
            }
        }
    }
}

2. 线程休眠

  • sleep(毫秒值)，指定当前线程阻塞的毫秒数
  • sleep存在异常InterruptedException
  • sleep时间达到后线程进入就绪状态
  • sleep可以模拟网络延迟，倒计时等
  • 每一个对象都有一个锁，sleep不会释放锁
public class ThreadSleep {
    public static void main(String[] args) {
        try {
            tenDown();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public static void tenDown() throws InterruptedException {
        int num = 10;
        while (true) {
            /*每1秒打印一次*/
            Thread.sleep(1000);
            System.out.println(num--);
            if (num <= 0) {
                break;
            }
        }
    }
}

实际应用：打印当前系统时间

/**
 * 每秒打印当前时间
 */
public static void main(String[] args) {
        /*获取系统当前时间*/
        Date startDate = new Date(System.currentTimeMillis());
        while (true) {
            try {
                Thread.sleep(1000);
                System.out.println(new SimpleDateFormat("HH:mm:ss").format(startDate));
                /*更新当前时间*/
                startDate = new Date(System.currentTimeMillis());
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

3. 线程礼让

  • 礼让线程，让当前正在执行的线程暂停，但不阻塞
  • 将线程从运行状态转为就绪状态
  • 让CPU重新调度，礼让不一定成功，看CPU心情
public class ThreadYield {
    public static void main(String[] args) {
        final MyYield myYield = new MyYield();
        new Thread(myYield, "A").start();
        new Thread(myYield, "B").start();
    }
}

class MyYield implements Runnable {
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + "线程开始执行");
        /*礼让*/
        Thread.yield();
        System.out.println(Thread.currentThread().getName() + "线程停止执行");
    }
}

其中一种结果：

A线程开始执行
B线程开始执行
B线程停止执行
A线程停止执行

4. Join合并线程

  • Join合并线程，待此线程执行完成后，在执行其他线程，其他线程阻塞
  • 可以想象成插队
public class ThreadJoin implements Runnable {
    @Override
    public void run() {
        int a = 5;
        for (int i = 0; i < a; i++) {
            System.out.println("VIP线程来了:" + i);
        }
    }

    public static void main(String[] args) throws InterruptedException {
        /*启动我们的线程*/
        final ThreadJoin threadJoin = new ThreadJoin();
        final Thread thread = new Thread(threadJoin);
        thread.start();

        /*主线程*/
        int b = 5;
        for (int i = 0; i < b; i++) {
            if (i == 3) {
                /*插队*/
                thread.join();
            }
            System.out.println("main:" + i);
        }
    }
}

结果：

main:0
main:1
main:2
VIP线程来了:0
VIP线程来了:1
VIP线程来了:2
VIP线程来了:3
VIP线程来了:4
main:3
main:4

5. 线程状态观测

Thread.State：线程可处于以下状态之一：

  • NEW

    尚未启动的线程处于此状态

  • RUNNABLE

    在Java虚拟机中执行的线程处于此状态

  • BLOCKED

    被阻塞等待监视器锁定的线程处于此状态

  • WAITING

    正在等待另一个线程执行特定动作的线程处于此状态

  • TIMED_WAITING

    正在等待另一个线程执行动作达到指定等待时间的线程处于此状态

  • TERMINATED

    已退出的线程处于此状态

一个线程可以在给定时间点处于一个状态。这些状态是不反映任何操作系统线程状态的虚拟机状态。

public class ThreadStateTest {
    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(()->{
            int a = 5;
            for (int i = 0; i < a; i++) {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println("//");
        });

        /*观察状态*/
        Thread.State state = thread.getState();
        /*NEW*/
        System.out.println(state);

        /*观察启动后的状态，并更新*/
        thread.start();
        state = thread.getState();
        /*RUN*/
        System.out.println(state);

        /*只要线程不终止，就一直更新并输出状态*/
        while (state != Thread.State.TERMINATED) {
            Thread.sleep(100);
            state = thread.getState();
            System.out.println(state);
        }
    }
}

结果：

NEW
RUNNABLE
TIMED_WAITING
TIMED_WAITING
TIMED_WAITING
...（省略一部分）
TIMED_WAITING
TIMED_WAITING
//
TERMINATED

6. 线程优先级

Java提供一个线程调度器来监控程序中启动后进入就绪状态的所有线程，线程调度器按照优先级决定应该调度哪个线程来执行。

线程的优先级用数字表示，范围从1~10：

  • Thread.MIN_PRIORITY = 1
  • Thread.MAX_PRIORITY = 10
  • Thread.NORM_PRIORITY = 5

使用以下方式改变或获取优先级：

  • getPriority().setPriority(int xxx)

优先级低只是意味着获得调度的概率低，并不是优先级低就不会被调用了，这都是看CPU的调度。

7. 守护（daemon）线程

线程分为用户线程和守护线程，虚拟机必须确保用户线程执行完毕，但是不用等待守护线程执行完毕，如：后台记录操作日志，监控内存，垃圾回收等待

public class ThreadDaemonTest {
    public static void main(String[] args) {
        final Guardian guardian = new Guardian();
        final Admin admin = new Admin();

        final Thread thread = new Thread(guardian);
        /*默认是false表示的用户线程，正常的线程都是用户线程*/
        thread.setDaemon(true);
        /*守护线程启动*/
        thread.start();

        /*用户线程启动*/
        new Thread(admin).start();
    }
}

/**
 * 守护者
 */
class Guardian implements Runnable {
    @Override
    public void run() {
        while (true) {
            System.out.println("守护中...");
        }
    }
}

/**
 * 用户线程
 */
class Admin implements Runnable {
    @Override
    public void run() {
        int a = 5;
        for (int i = 0; i < a; i++) {
            System.out.println("A在运行...");
        }
        System.out.println("A停下来了");
    }
}

结果：

守护中...
守护中...
A在运行...
A在运行...
A在运行...
A在运行...
A在运行...
A停下来了
守护中...
守护中...
守护中...
守护中...
守护中...

二、线程同步

线程同步就是多个线程操作同一个资源，现实生活中，我们也会遇到“同一个资源，多个人都想使用”的问题，那么如何解决呢？最直观的解决办法就是——排队，一个一个来。

处理多线程问题时，多个线程访问同一个对象（并发），并且某些线程还想修改这个对象，这时候我们就需要线程同步。

线程同步是一种等待机制，多个需要同时访问此对象的线程进入这个对象的等待池形成队列，等待前面线程使用完毕，下一个线程再使用。

1. 队列和锁

线程同步的形成就是队列+锁，可以能保证我们线程的安全性

由于同一进程的多个线程共享同一块存储空间，在带来方便的同时，也带来了访问冲突问题，为了保证数据在方法中被访问时的正确性，在访问时加入锁机制synchronized，当一个线程获得对象的排它锁，独占资源，其他线程必须等待，使用后释放锁即可。

  • 一个线程持有锁会导致其他所有需要此锁的线程挂起
  • 在多线程竞争下，加锁，释放锁会导致比较多的上下文切换和调度延时，引起性能问题
  • 如果一个优先级高的线程等待一个优先级低的线程释放锁，会导致优先级倒置，引起性能问题

2. 同步方法

由于我们可以通过private关键字来保证数据对象只能被方法访问，所以我们只需要针对方法提出一套机制,这套机制就是synchronized关键字，它包括两种用法：synchronized方法和synchronized块。

同步方法：public synchronized void method(int args){}

synchronized方法控制对“对象”的访问，每个对象对应一把锁，每个synchronized方法都必须获得调用该方法的对象的锁才能执行，否则线程会阻塞，方法一旦执行，就独占该锁，直到该方法返回才释放锁，后面被阻塞的线程才能获得这个锁，继续执行。

缺陷：若将一个大的方法申明为synchronized将会影响效率

方法里面需要修改的内容才需要锁，锁的太多，浪费资源

/**
 * 不安全的买票
 */
public class UnsafeBuyTicket {
    public static void main(String[] args) {
        final BuyTicket buyTicket = new BuyTicket();
        new Thread(buyTicket,"A").start();
        new Thread(buyTicket,"B").start();
        new Thread(buyTicket,"C").start();
    }
}

class BuyTicket implements Runnable {

    /**
     * 票
     */
    private int ticketNums = 5;
    boolean flag = true;

    /**
     * 买票（同步方法，锁的是this）
     */
    private synchronized void buy() {
        /*判断是否有票*/
        if (ticketNums <= 0) {
            flag = false;
            return;
        }
        /*模拟延时，sleep可以放大问题的发生性*/
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        /*买票*/
        System.out.println(Thread.currentThread().getName() + "拿到第" + ticketNums-- + "张票");
    }

    @Override
    public void run() {
        /*买票*/
        while (flag) {
            buy();
        }

    }
}

上面的代码如果没有线程同步，就会出现多个人拿到了同一张票，这显然是不安全的。

在buy()方法中加入了synchronized，此时调用这个方法就需要拿到锁，没有锁就会排队等待，直到拿到锁再进行调用，这样就可以保证线程的安全。

结果：

A拿到第5张票
A拿到第4张票
C拿到第3张票
B拿到第2张票
B拿到第1张票

3. 同步块

同步块：synchronized(Obj){}

Obj称之为同步监视器

  • Obj可以是任何对象，但是推荐使用共享资源作为同步监视器
  • 同步方法中无需指定同步监视器，因为同步方法的同步监视器就是this，就是这个对象本身，或者是class

同步监视器的执行过程：

  1. 第一个线程访问，锁定同步监视器，执行其中代码
  2. 第二个线程访问，发现同步监视器被锁定，无法访问
  3. 第一个线程访问完毕，解锁同步监视器
  4. 第二个线程访问，发现同步监视器没有锁，然后锁定并访问
/**
 * 线程不安全的取钱
 */
public class UnsafeBank {
    public static void main(String[] args) {
        /*账户*/
        final Account account = new Account(100, "账户");
        /*银行*/
        final Drawing jia = new Drawing(account, 50, "甲");
        final Drawing yi = new Drawing(account, 100, "乙");

        jia.start();
        yi.start();
    }
}

/**
 * 账户
 */
class Account {
    /**
     * 余额
     */
    int money;
    /**
     * 卡名
     */
    String name;

    public Account(int money, String name) {
        this.money = money;
        this.name = name;
    }
}

/**
 * 银行：模拟取款
 */
class Drawing extends Thread{
    /**
     * 账户
     */
    final Account account;
    /**
     * 取了多少钱
     */
    int drawingMoney;
    /**
     * 现在手里有多少钱
     */
    int nowMoney;

    public Drawing(Account account, int drawingMoney, String name) {
        super(name);
        this.account = account;
        this.drawingMoney = drawingMoney;
    }

    /**
     * 取钱
     */
    @Override
    public void run() {

        /*锁的对象就是变化的量（需要增删改的对象）*/
        synchronized (account) {
            /*判断有没有钱*/
            if (account.money - drawingMoney < 0) {
                System.out.println(Thread.currentThread().getName() + "无法取钱，余额不足...");
                return;
            }

            /*sleep放大问题的发生性*/
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            /*卡内余额 = 余额 - 取出来的钱*/
            account.money = account.money - drawingMoney;

            /*现在你手里的钱 = 你手里的钱 + 取出来的钱*/
            nowMoney = nowMoney + drawingMoney;

            System.out.println(account.name + "余额为：" + account.money);
            System.out.println(Thread.currentThread().getName() + "手里的钱有：" + nowMoney);
        }
    }
}

上面的代码如果没有加入同步块，就会出现余额不足也会取到钱，最终余额为负数的情况，这也是不安全的。

银行没有变化，余额发生了变化，所以需要将同步块加到会发生增删改变化的地方，也就是锁余额，这样当发现余额不足时才不会继续取钱。

结果：

账户余额为：50
甲手里的钱有：50
乙无法取钱，余额不足...

ArrayList集合也是线程不安全的，但是可以通过添加同步块的方式保证线程安全。

4. 死锁

多个线程各自占有一些共享资源，并且互相等待其他线程占有的资源才能运行，而导致两个或者多个线程都在等待对方释放资源，都停止执行的情况。某一个同步块同时拥有“两个以上对象的锁”时，就可能会发生“死锁”的问题。

死锁的产生条件

产生死锁的四个必要条件：

  1. 互斥条件：一个资源每次只能被一个进程使用（资源独立）
  2. 请求与保持条件：一个进程因请求资源而阻塞时，对已获得的资源保持不放（不释放锁）
  3. 不剥夺条件：进程以获得的资源，在未使用完之前，不能强行剥夺（抢夺资源）
  4. 循环等待条件：若干进程之间形成一种头尾相接的循环等待资源关系（死循环）

如何避免死锁

我们只要想办法破其中的任意一个或多个条件就可以避免死锁的发生。

  1. 破坏”互斥”条件：系统里取消互斥、若资源一般不被一个进程独占使 用，那么死锁是肯定不会发生的，但一般“互斥”条件是无法破坏的，因此，在死锁预防里主要是破坏其他三个必要条件，而不去涉及破坏“互斥”条件。

  2. 破坏“请求和保持”条件：

    方法 1：所有的进程在开始运行之前，必须一次性的申请其在整个运行过程各种所需要的全部资源。

    • 优点：简单易实施且安全。
    • 缺点：因为某项资源不满足，进程无法启动，而其他已经满足了的资源也不会得到利用，严重降低了资源的利用率，造成资源浪费。

    方法 2：该方法是对第一种方法的改进，允许进程只获得运行初期需要的资源，便开始运行，在运行过程中逐步释放掉分配到，已经使用完毕的资源，然后再去请求新的资源。这样的话资源的利用率会得到提高，也会减少进程的饥饿问题。

  3. 破坏“不剥夺”条件：当一个已经持有了一些资源的进程在提出新的资源请求没有得到满足时，它必须释放已经保持的所有资源，待以后需要使用的时候再重新申请。这就意味着进程已占有的资源会被短暂的释放或者说被抢占了。

  4. 破坏“循环等待”条件：可以通过定义资源类型的线性顺序来预防，可 以将每个资源编号，当一个进程占有编号为 i 的资源时，那么它下一次申请资源只能申请编号大于 i 的资源。

/**
 * 死锁：多个线程互相抱着对方需要的资源，然后形成僵持
 */
public class DeadLock {
    public static void main(String[] args) {
        final Makeup m1 = new Makeup(0, "灰姑娘");
        final Makeup m2 = new Makeup(1, "白雪公主");
        m1.start();
        m2.start();
    }
}

/**
 * 口红
 */
class Lipstick {}

/**
 * 镜子
 */
class Mirror {}

/**
 * 化妆
 */
class Makeup extends Thread {
    static final Lipstick LIPSTICK = new Lipstick();
    static final Mirror MIRROR = new Mirror();
  
    /**
     * 选择
     */
    int choice;
    /**
     * 使用化妆品的人
     */
    String name;
    public Makeup(int choice, String name) {
        this.choice = choice;
        this.name = name;
    }

    @Override
    public void run() {
        /*化妆*/
        try {
            makeup();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    /**
     * 化妆：互相持有对方的锁，就是需要拿到对方的资源
     */
    private void makeup() throws InterruptedException {
        if (choice == 0) {
            /*获取口红的锁*/
            synchronized (LIPSTICK) {
                System.out.println(this.name + "获得口红的锁");
                Thread.sleep(1000);
            }
            /*一秒钟后想获得镜子（等待释放获取口红的锁再来拿获取镜子的锁就可以避免死锁）*/
            synchronized (MIRROR) {
                System.out.println(this.name + "获得镜子的锁");
            }
        } else {
            /*获取镜子的锁*/
            synchronized (MIRROR) {
                System.out.println(this.name + "获得镜子的锁");
                Thread.sleep(2000);
            }
            /*一秒钟后想获得口红（等待释放获取镜子的锁再来拿获取口红的锁就可以避免死锁）*/
            synchronized (LIPSTICK) {
                System.out.println(this.name + "获得口红的锁");
            }
        }
    }
}

结果：

白雪公主获得镜子的锁
灰姑娘获得口红的锁
白雪公主获得口红的锁
灰姑娘获得镜子的锁

5. Lock（锁）

从JDK5.0开始，Java提供了更强大的线程同步机制——通过显式定义同步锁对象来实现同步。同步锁使用Lock对象充当。

java.util.concurrent.locks.Lock接口是控制多个线程对共享资源进行访问的工具。锁提供了对共享资源的独占访问，每次只能有一个线程对Lock对象加锁，线程开始访问共享资源之前应先获得Lock对象。

ReentrantLock类实现了Lock，它拥有与synchronized相同的并发性和内存语义，在实现线程安全的控制中，比较常用的是ReentrantLock（可重入锁），可以显式加锁、释放加锁。

class TestLock implements Runnable {

    private final ReentrantLock lock = new ReentrantLock();

    @Override
    public void run() {
        lock.lock();
        try {
            /*保证线程安全的代码*/
        } finally {
            /*如果同步代码块有异常，要将unlock()写入finally语句块*/
            lock.unlock();
        }
    }
}
synchronized与Lock的对比

  • Lock是显式锁（需要手动开启和关闭锁），synchronized是隐式锁（出了作用域自动释放）

  • Lock只有代码块锁，synchronized有代码块锁和方法锁

  • 使用Lock锁，JVM将花费较少的时间来调度线程，性能更好，并且具有更好的扩展性（提供更多的子类）

  • 优先使用顺序：

    Lock > 同步代码块（已经进入了方法体，分配了相应资源） > 同步方法（在方法体之外）

三、线程协作

1. 线程通信分析

这是一个线程同步问题，生产者和消费者共享同一个资源，并且生产者和消费者之间相互依赖，互为条件。

  • 对于生产者，没有生产产品之前，要通知消费者等待；而生产了产品之后，又需要马上通知消费者消费
  • 对于消费者，在消费之后，要通知生产者已经结束消费，需要生产新的产品以供消费
  • 在生产者消费者问题中，仅有synchronized是不够的
    • synchronized可阻止并发更新同一个共享资源，实现了同步
    • synchronized不能用来是心啊不同线程之间的消息传递（通信）

Java提供了几个方法解决线程之间的通信问题

方法名作用
wait()表示线程一直等待，直到其他线程通知，与sleep()不同，会释放锁
wait(Long timeout)指定等待的毫秒数
notify()唤醒一个处于等待状态的线程
notifyAll()唤醒同一个对象上所有调用wait()方法的线程，优先级别搞得线程优先调度

注意：均是Object类的方法，都只能在同步方法或者同步代码块中使用，否则会抛出异常IllegalMonitorStateRxception。

解决方式一：管程法

并发协作模型“生产者/消费者模式”–>管程法

  • 生产者：负责生产数据的模块（可能是方法、对象、线程、进程）
  • 消费者：负责处理数据的模块（可能是方法、对象、线程、进程）
  • 缓冲区：消费者不能直接使用生产者的数据，它们之间有个“缓冲区”

生产者将生产好的数据放入缓冲区，消费者从缓冲区拿出数据

/**
 * 测试：生产者消费者模型-->利用缓冲区解决：管程法
 * 生产者，消费者，产品，缓冲区
 * 每生产完一只鸡，才会让消费者进行消费
 */
public class TestPc {
    public static void main(String[] args) {
        final SyContainer container = new SyContainer();

        new Producer(container).start();
        new Consumer(container).start();
    }

}

/**
 * 生产者
 */
class Producer extends Thread {
    SyContainer container;

    public Producer(SyContainer container) {
        this.container = container;
    }

    /**
     * 生产
     */
    @Override
    public void run() {
        int a = 100;
        for (int i = 0; i < a; i++) {
            container.push(new Chicken(i));
            System.out.println("生产了" + i + "只鸡");
        }
    }
}

/**
 * 消费者
 */
class Consumer extends Thread {
    SyContainer container;

    public Consumer(SyContainer container) {
        this.container = container;
    }

    /**
     * 消费
     */
    @Override
    public void run() {
        int a = 100;
        for (int i = 0; i < a; i++) {
            System.out.println("消费了第" + container.pop().id + "只鸡");
        }
    }
}

/**
 * 产品
 */
class Chicken {
    /**
     * 产品编号
     */
    int id;

    public Chicken(int id) {
        this.id = id;
    }
}

/**
 * 缓冲区
 */
class SyContainer {
    /**
     * 需要一个容器大小
     */
    Chicken[] chickens = new Chicken[10];

    /**
     * 容器计数器
     */
    int count = 0;

    /**
     * 生产者放入产品
     */
    public synchronized void push(Chicken chicken) {
        /*如果容器满了，就需要等待消费者消费*/
        if (count == chickens.length) {
            /*通知消费者消费，生产者等待*/
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        /*如果没有满，我们就需要丢入产品*/
        chickens[count] = chicken;
        count++;

        /*可以通知消费者消费了*/
        this.notifyAll();
    }

    /**
     * 消费者消费产品
     */
    public synchronized Chicken pop() {
        /*判断能否消费*/
        if (count == 0) {
            /*消费者等待*/
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        /*如果可以消费*/
        count--;
        Chicken chicken = chickens[count];

        /*吃完了，通知生产者生产*/
        this.notifyAll();
        return chicken;
    }
}
解决方式二：信号灯法

并发协作模型“生产者/消费者模式”–>信号灯法

/**
 * 测试生产者消费者问题2：信号灯法，标志位解决
 * 无论播放什么，都是演员先拍，观众再看
 */
public class TestPc2 {
    public static void main(String[] args) {
        Tv tv = new Tv();
        new Player(tv).start();
        new Watcher(tv).start();
    }

}

/**
 * 生产者-->演员
 */
class Player extends Thread {
    Tv tv;

    public Player(Tv tv) {
        this.tv = tv;
    }

    @Override
    public void run() {
        int a = 20;
        for (int i = 0; i < a; i++) {
            if (i % 2 == 0) {
                this.tv.play("电视剧播放中...");
            } else {
                this.tv.play("广告中...");
            }
        }
    }
}

/**
 * 消费者-->观众
 */
class Watcher extends Thread {
    Tv tv;

    public Watcher(Tv tv) {
        this.tv = tv;
    }

    @Override
    public void run() {
        int a = 20;
        for (int i = 0; i < a; i++) {
            tv.watch();
        }
    }
}

/**
 * 产品-->电视剧
 */
class Tv {
    /*演员录电视剧，观众等待 T*/
    /*观众看电视剧，演员等待 F*/
    /**
     * 拍好的一集电视剧
     */
    String voice;
    boolean flag = true;

    /**
     * 表演
     * @param voice 一集电视剧
     */
    public synchronized void play(String voice) {
        if (!flag) {
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println("演员录好了：" + voice);
        /*通知观众观看 通知唤醒*/
        this.notifyAll();
        this.voice = voice;
        this.flag = !this.flag;
    }

    /**
     * 观看
     */
    public synchronized void watch() {
        if (flag) {
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println("观众观看了：" + voice);
        /*通知演员录制新的一集*/
        this.notifyAll();
        this.flag = !this.flag;
    }
}

2. 线程池

背景：经常创建和销毁，使用量特别大的资源，比如并发情况下的线程，对性能影响很大。

思路：提前创建好多个线程，放入线程池中，使用时直接获取，使用完放回池中。可以避免频繁创建销毁，实现重复利用。类似生活中的公共交通工具。

好处：

  • 提高响应速度（减少了创建新线程的时间）
  • 减低资源消耗（重复利用线程池中的线程，不需要每次都创建）
  • 便于线程管理
    • corePoolSize：核心池的大小
    • maximumPoolSize：最大线程数
    • keepAliveTime：线程没有任务时最多保持多长时间后会终止

JDK5.0提供了线程池相关API：ExecutorService和Executors

ExecutorService：真正的线程池接口。常见子类ThreadPoolExecutor

  • void execute(Runnable command)：执行任务/命令，没有返回值，一般用来执行Runnable
  • <T>Future<T> submit(Callable<T> task)：执行任务，有返回值，一般用来执行Callable
  • void shutdown()：关闭连接池

Executors：工具类、线程池的工厂类，用于创建并返回不同类型的线程池

/**
 * 测试线程池
 */
public class TestPool {
    public static void main(String[] args) {
        /*创建服务，创建线程池,参数为线程池大小*/
        ExecutorService service = Executors.newFixedThreadPool(10);
        /*执行*/
        service.execute(new MyThread());
        service.execute(new MyThread());
        service.execute(new MyThread());
        service.execute(new MyThread());
        /*关闭连接*/
        service.shutdown();
    }
}

class MyThread implements Runnable {
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName());

    }
}

四、相关问题

线程的基本方法有什么？

线程相关的基本方法有wait，notify，notifyAll，sleep，join，yield等。

  1. 线程等待（wait）

    调用该方法的线程进入WAITING状态，只有等待另外线程的通知或被中断才会返回，需要注意的是调用wait()方法后，会释放对象的锁。因此，wait 方法一般用在同步方法或同步代码块中。

  2. 线程睡眠（sleep）

    sleep导致当前线程休眠，与wait方法不同的是sleep不会释放当前占有的锁，sleep(long)会导致线程进入TIMED-WATING状态，而wait()方法会导致当前线程进入WATING状态。

  3. 线程让步（yield）

    yield会使当前线程让出CPU执行时间片，与其他线程一起重新竞争 CPU 时间片。一般情况下，优先级高的线程有更大的可能性成功竞争得到CPU时间片，但这又不是绝对的，有的操作系统对线程优先级并不敏感。

  4. 线程中断（interrupt）

    中断一个线程，其本意是给这个线程一个通知信号，会影响这个线程内部的一个中断标识位。这个线程本身并不会因此而改变状态(如阻塞，终止等)。

  5. Join等待其他线程终止

    join()方法，等待其他线程终止，在当前线程中调用一个线程的join() 方法，则当前线程转为阻塞状态，回到另一个线程结束，当前线程再由阻塞状态变为就绪状态，等待cpu的调用。

  6. 线程唤醒（notify）

    Object 类中的notify()方法，唤醒在此对象监视器上等待的单个线程，如果所有线程都在此对象上等待，则会选择唤醒其中一个线程，选择是任意的，并在对实现做出决定时发生，线程通过调用其中一个wait()方法，在对象的监视器上等待，直到当前的线程放弃此对象上的锁定，才能继续执行被唤醒的线程，被唤醒的线程将以常规方式与在该对象上主动同步的其他所有线程进行竞争。类似的方法还有notifyAll()，唤醒再次监视器上等待的所有线程。

在java中wait和sleep方法的不同？

最大的不同是在等待时wait会释放锁，而sleep一直持有锁。wait 通常被用于线程间交互，sleep通常被用于暂停执行。

Lee-hehe
关注
多线程——线程实现、线程状态、线程同步、线程通信、线程池
weixin_44090845的博客
11-22 3523
多线程一、线程1.普通方法调用和多线程2.程序、进行、线程二、线程创建1.继承Thread类2.实现Runable接口3.实现Callable接口4.静态代理模式5、Lamda表达式三、线程状态1.线程状态2.线程方法3.线程停止4.线程休眠sleep5.线程礼让5.join6.线程状态观测7.线程优先级8.守护(daemon)线程四、线程同步1.并发与并行2.线程同步——等待机制2.1 队列 和 锁2.2 线程同步2.3 同步方法2.4 同步块3.死锁4. Lock锁 一、线程 1.普通方法调用和多线程
java多线程基础
weixin_42873746的博客
11-16 275
多线程 1. 线程简介 1.1 普通方法调用和多线程 一个进程可以有多个线程，如视频中同时听声音，看图像，看弹幕，等等 1.2 Process与Thread 程序是指令和数据的有序集合，其本身没有任何运行的含义，是一个静态的概念 而进程则是执行程序的一次执行过程，它是一个动态的概念。是系统资源分配的单位 通常一个进程中可以包含若干个线程，当然一个进程中至少有一个线程，不然没有存在的意义。线程是CPU调度和执行的单位。 注意：很多多线程是模拟出来的，真正的多线程是指有多个cpu，即多核，如服务器。如果是
线程的同步状态
一切的困难都来自于自己内心的恐惧
11-08 639
线程的各个流程之间转换的关系图： 说明 ： 线程的同步状态主要包含5种状态的转换： 1. 初始状态(New) : 也就是线程对象被新建后就进入初始状态。例如，Thread thread = new Thread()。 2. 就绪状态(Runnable): 也被称为“可执行状态”。线程对象被创建后，调用该对象的start()方法启动了线程。此时线程就进入到了就绪状态。注意...
线程同步方式，线程状态及其转换
yiyiyuebing的博客
03-23 184
线程同步的方式 互斥量 Synchronized/Lock：采用互斥对象机制，只有拥有互斥对象的线程才有访问公共资源的权限。因为互斥对象只有一个，所以可以保证公共资源不会被多个线程同时访问 信号量 Semphare：它允许同一时刻多个线程访问同一资源，但是需要控制同一时刻访问此资源的最大线程数量 事件(信号)，Wait/Notify：通过通知操作的方式来保持多线程同步，还可以方便的实现多线程优先...
线程+同步+线程状态
sgw101的博客
09-17 155
文章目录一.多线程1.1 并发与并行1.2 线程与进程1.3 创建线程类二.多线程(详细)2.1 多线程原理2.2 Thread类2.3 实现接口方式2.4 匿名内部类方式三.线程安全3.1 线程安全3.2 线程同步3.3 同步代码块3.4 同步方法3.5 Lock锁四.线程状态4.1 线程状态概述4.2 睡眠sleep方法4.3 等待和唤醒4.4 等待唤醒案例（包子铺卖包子） 一.多线程 1.1...
线程_同步_线程状态
laughing
02-29 97
线程 并发：同一个时间段内； 并行：同一时刻； 进程：系统运行的一个程序； 线程：进程的一个执行单元； 线程调度： 分时调度：轮流占用CPU使用权； 抢占式调度：优先级高的进程优先占用CPU使用权，优先级别相同时就分时调度； 线程类： 1，继承Thread类，重写run()方法； 2，实现Runable接口，重写run()方法； 实例对象调用start()方法开辟一个栈内...
11.Linux线程同步
01-06
文章目录一、线程同步的概念二、互斥锁1、初始化锁2、阻塞加锁3、非阻塞加锁4、解锁5、销毁锁（此时锁必需unlock状态，否则返回EBUSY）三、示例程序四、版权声明 一、线程同步的概念 线程同步？怎么同步？一起运行？...
java 实现线程同步的方式有哪些
09-05
Java中的线程同步是解决多线程环境下并发访问共享数据可能导致的数据不一致性问题的关键技术。在Java中，有多种方式可以实现线程同步，确保在任何时刻只有一个线程能够访问特定的共享资源。 1. **同步代码块 ...
Java中的线程同步与ThreadLocal无锁化线程封闭实现
09-02
ThreadLocal不是用来解决线程同步问题的，而是用来避免线程间的共享状态，从而减少同步的需求。在上述提到的项目困境中，ThreadLocal可以提供一种解决方案。例如，可以创建一个ThreadLocal变量，每个线程在需要时...
python 线程的五个状态
12-16
Python线程是并发执行任务的重要工具，特别是在处理I/O密集型任务时，通过多...在Python中，可以使用`threading`模块提供的API来控制线程状态，实现线程间的通信和协作，从而编写出更加灵活和健壮的多线程应用程序。
多线程详解——中（线程状态、线程同步）
nswdiphone6的博客
02-04 241
3.线程状态 线程方法： setPriority(int newPriority) 更改线程的优先级。 static void sleep(long millis) 在指定的毫秒数内让当前正在执行的线程体休眠。 void join()等待改线程终止 static void yield() 暂停当前正在执行的线程对象，并执行其他线程 void interrupt() 中断线程 （不建议使用） boolean isAlive() 测试线程是否处于活动状态 停止线程： 不推荐使用JDK提供的stop()、
线程面试题之一：父子线程的同步
hehengchong的专栏
08-13 1183
子线程循环10次，接着主线程循环100次
线程同步的四种方式及原理
最新发布
向诸位大佬虚心学习
03-11 2883
线程的同步是为了保证多个线程按照特定的顺序、协调地访问共享资源，避免数据不一致和竞争条件等问题。本文说明了四种实现线程同步的方式。
创建子父线程 保证一件事情 子线程执行三次后 父线程执行5次 如此循环十次
qq_42585774的博客
10-03 353
public class FatherAndSon{ bokean flag=true; public synchronized void father(){ //理当父线程不执行 wait():如果在一个线程 中调用了obj.wait():自己本身进入阻塞状态 并释放对锁的占有(立即释放) // notify(): 唤醒...
（转）【最新】抖音相关工具合集--在线观看，网页版，去水印下载视频，下载音乐，音乐榜单等
热门推荐
qq_42561194的博客
06-27 25万+
抖音去水印：https://welltool.net这个工具除了支持单视频去水印，还支持用户发过的视频，抖音话题视频列表，使用音乐发过的视频列表批量下载除了下载无水印视频，还是支持下载背景音，视频封面。还可以查看视频的点赞数，评论数，分享数等信息，非常的方便抖音网页版在线观看：https://www.welltool.net/douyinweb这个网站可以直接看抖音热门视频，每小时更新，可以变干活...
线程中主线程与子线程之间的关系
NasubiZW
12-12 2万+
1、最常见的情况，主线程中开启了一个子线程，开启之后，主线程与子线程互不影响各自的生命周期，即主线程结束，子线程还可以继续执行；子线程介素，主线程也能继续执行。 测试代码如下： public class TestThread{ public static void main(String[] args) throws InterruptedException { System.out.prin...
future的简单实现
u011381576的博客
06-21 1111
一 .入门相信大家使用过线程，对future应该不会陌生吧! 在java一种最简单的使用是Callable,比如：public class A implements Callable&lt;String&gt; { @Override public String call() throws Exception { return "aaa"; } }@org....
Java Future接口、Future模式理解
D137716858的专栏
04-11 4928
Future接口介绍： 在Java中，如果需要设定代码执行的最长时间，即超时，可以用Java线程池ExecutorService类配合Future接口来实现。 Future接口是Java标准API的一部分，在java.util.concurrent包中。Future接口是Java线程Future模式的实现，可以来进行异步计算。 Future模式可以这样来描述：我有一个任务，提交给了
C/C++ 子线程阻塞主线程
highoooo的博客
11-23 1756
如果不需要子线程阻塞主线程，就不要调用join方法 thread生成后就已经在执行了，不需要.join 研究以下.join .detach几个thread相关的方法
C#线程同步详解：锁、事件与线程状态
本部分主要介绍了线程同步的基础知识，包括各种同步机制、线程状态以及阻止与非阻止同步的方法。 1. **同步要领** - **线程的阻止**（Blocking）：通过调用如`Sleep`、`Join`等方法，线程会进入等待状态，释放CPU...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Lee-hehe

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值