多线程（十）多线程编程示例

最新推荐文章于 2023-08-29 14:35:26 发布
最新推荐文章于 2023-08-29 14:35:26 发布
阅读量165 收藏
点赞数
分类专栏： java 并发编程 文章标签： 多线程
原文链接：https://blog.csdn.net/m0_37741420/article/details/110225520
版权

文章目录

一、交替输出1A2B3C4D5E…

  用两个线程，一个输出数字，一个输出字母，最后的结果是交替输出1A2B3C4D5E…

1.1 synchronized/wait/notify

  说到线程的运用，最先想到的可能就是“synchronized/wait/notify”的组合：

  1. 用synchronized锁住一个对象，达到同一时间只能有一个线程输出的目的；
  2. 用wait和notify进行线程间的通信，达到交替输出的目的。

  上面的思路总体上来说没有问题，不过两个线程同时启动时，获得CPU时间片的次序是不固定的，因此需要用一个变量来控制先输出数字。示例：

public class ThreadTest {
    
	private static volatile boolean t2Started = false;
    final Object lock = new Object();
    char[] arrI = "1234567".toCharArray();
    char[] arrC = "ABCDEFG".toCharArray();

    public static void main(String[] args) {
		new ThreadTest().testSyncWaitNofiy();
	}
    
    public void testSyncWaitNofiy() {
        new Thread(() -> {
            synchronized (lock) {
                while (!t2Started) {
                    try {
                    	lock.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                for (char c : arrC) {
                    System.out.print(c);
                    try {
                    	lock.notify();
                    	lock.wait();//让出锁
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                lock.notify();//必须，否则无法终止程序
            }
        }, "t1").start();
        
        new Thread(() -> {
            synchronized (lock) {
                for (char c : arrI) {
                    System.out.print(c);
                    t2Started = true;
                    try {
                    	lock.notify();
                    	lock.wait();//让出锁
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                lock.notify();//必须，否则无法终止程序
            }
        }, "t2").start();
    }
}

  以上是经典的交替输出写法，以上代码有两种执行顺序：

  • 1、t1先执行
      假如t1先获得CPU时间片，会走入以下逻辑：

      接着t1线程被暂停，t2线程获得锁，将t2Started变量置为true，然后打印数字，唤醒t1，t2线程自身被暂停。
      这时t1线程获得锁，开始打印字母，然后唤醒t2，自己暂停 ------> t2线程获得锁，开始打印数组，然后唤醒t1，自己暂停…
      最后，t2输出数字"7"，然后唤醒t1，自己暂停。t1输出字母"G"，然后唤醒t2，自己暂停。这时t1线程中第二个notify的作用就体现出来了。假如t1中没有第二个notify，在t1获得锁后，什么也不做，然后释放锁。但是由于没有唤醒其他被暂停的线程，t2将会一直被暂停！
      所以即便t1线程的数字数组arrI已经不打印任何字母了，还是需要将暂停的t2线程唤醒，达到两个线程都停止的目的。
  • 2、t2先执行
      如果t2线程先获得时间片，相当于直接进入打印数字的逻辑，t1中while循环相关的代码不会被执行。

1.2 Condition/await/signal

  用Lock和synchronized的逻辑，总体上是一样的，不过是将隐式锁换成了显式锁而已。示例：

public class ThreadTest {
    
	private static volatile boolean t2Started = false;
    char[] arrI = "1234567".toCharArray();
    char[] arrC = "ABCDEFG".toCharArray();

    public static void main(String[] args) {
		new ThreadTest().testLockCondition();
	}
    
    public void testLockCondition() {
        Lock lock = new ReentrantLock();
        Condition conditionT1 = lock.newCondition();
        Condition conditionT2 = lock.newCondition();
        new Thread(() -> {
            try {
                lock.lock();
                while (!t2Started) {
                    try {
                    	conditionT1.await();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                for (char c : arrI) {
                    System.out.print(c);
                    conditionT2.signal();
                    conditionT1.await();
                }
                conditionT2.signal();
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                lock.unlock();
            }
        }, "t1").start();
        
        new Thread(() -> {
            try {
                lock.lock();
                for (char c : arrC) {
                    System.out.print(c);
                    t2Started = true;
                    conditionT1.signal();
                    conditionT2.await();
                }
                conditionT1.signal();
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                lock.unlock();
            }
        }, "t2").start();
    }
}

二、生产者–消费者问题

  生产者–消费者问题在之前的文章章已经介绍过，这里再写这个例子，是为了可以将这个例子和交替输出字符串的例子放在一起对比看：交替输出字符串的问题要达到交替输出（两个线程按顺序获取锁）的目的，所以在各自的线程中在暂停自身前先唤醒对方；而生产者消费者问题不需要两个线程交替执行，所以没有在暂停自身前唤醒对方的操作。
  在生产者—消费者问题中，生产者的主要职责是生产产品，产品既可以是数据，也可以是任务。消费者的主要职责是消费生产者生产的产品，这里的消费包括对产品所代表的数据进行加工处理或执行产品所代表的任务。
  生产者–消费者问题中，实际上主要是包含了两类线程，一种是生产者线程用于生产数据，另一种是消费者线程用于消费数据。
  为了解耦生产者和消费者的关系，通常会采用共享数据区的方式，生产者生产数据之后直接放置在共享数据区中，并不需要关心消费者的行为；消费者只需要从共享数据区中去获取数据，不再需要关心生产者的行为。这个共享数据区域中应该具备线程间并发协作的功能：

  1. 如果共享数据区已满的话，阻塞生产者继续放入数据；
  2. 如果共享数据区为空的话，阻塞消费者继续消费数据。

  在实现生产者消费者问题时，可以采用三种方式：

  1. 使用Object的wait/notify的消息通知机制；
  2. 使用Condition的await/signal的消息通知机制；
  3. 使用BlockingQueue实现（BlockingQueue在后续文章详细介绍）。

  通常，生产者和消费者的处理能力是不同的，即生产者生产产品的速率和消费者消费产品的速率是不同的，较为常见的情形是生产者的处理能力比消费者的处理能力大。这种情况下，传输通道所起的作用不仅仅作为生产者和消费者之间传递数据的中介，它在一定程度上还起到一个平衡生产者和消费者处理能力的作用。
  按照生产者数量和消费者数量的组合来划分，可以分为以下几种：

类别生产者线程数量消费者线程数量
单生产者-单消费者11
单生产者-多消费者1N（N>=2）
多生产者-多消费者N（N>=2）N（N>=2）
多生产者-单消费者N（N>=2）1

2.1 synchronized/wait/notify

  此种方式指的是：通过配合调用Object对象的wait方法和notify方法或notifyAll方法来实现线程间的通信，简单来说可以分为两个步骤：

  • 在线程中调用wait方法，将阻塞当前线程；
  • 其他线程调用了调用notify方法或notifyAll方法进行通知之后，当前线程才能从wait方法返回，继续执行下面的操作。

  假设有一个箱子，最多只能装10个苹果，箱子里没苹果时不能消费（简单理解为从箱子里往外取苹果），箱子里苹果的数量为10时不能生产（简单理解为向箱子里放苹果）。要实现这一效果，至少有三个点需要关注：

  1. 要达到阻塞生产者和消费者两种效果，需要用不同的条件判断+wait实现；
  2. 要达到通知生产者和消费者正常运行下去的效果，需要用notify/notifyAll实现（具体用哪种通知方法看需求，notify是随机通知一个，notifyAll是通知所有）；
  3. 要存放共享数据，需要选择合适的集合类（该例子比较简单，并没有用集合类，而是用了一个变量来实现）。

  示例：

//箱子，存量苹果的容器
public class Box {
	//箱子中目前苹果的数量
    int num;

    public synchronized void put() {
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        
        //10是箱子中能存放苹果的最大数量
        while (num == 10) {             
            try {
                System.out.println("箱子满了，生产者暂停");
                //等待消费者消费一个才能继续生产，所以要让出锁
                this.wait();                       
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        
        num++;
        System.out.println("箱子未装满，开始生产，生产后箱子中的苹果数量："+num);
        //唤醒可能因为没苹果而等待的消费者
        this.notify();     
    }
    
    public synchronized void take() {
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        
        while (num == 0) {          
            try {
                System.out.println("箱子空了，消费者暂停");
                //等待生产者生产一个才能继续消费,所以要让出锁
                this.wait();                      
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        
        num--;
        System.out.println("箱子中有了苹果，开始消费，消费后箱子中的苹果数量："+num);
        //唤醒可能因为苹果满了而等待的生产者
        this.notify();                    
    }
}

//消费者
public class Consumer implements Runnable {
	 
    private Box box;
 
    public Consumer(Box box) {
        this.box= box;
    }
 
    @Override
    public void run() {
        while (true){
            box.take();
        }
    }
}

//生产者
public class Producer implements Runnable {
	 
    private Box box;
 
    public Producer(Box box) {
        this.box= box;
    }
 
    @Override
    public void run() {
        while (true){
            box.put();
        }
    }
}

public class ConsumerAndProducer {
	 
    public static void main(String[] args) {
        Box box = new Box();
        //生产者线程
        Producer p1 = new Producer(box);  
        //消费者线程
        Consumer c1 = new Consumer(box);    
 
        new Thread(p1).start();
        new Thread(c1).start();
    }
}

  结果示例：

2.2 Condition/await/signal

  该种方式实现生产者消费者，和之前一种方式原理是一样的，不过是将隐式锁换成了显式锁而已。以上个小节的功能为例，修改Box.java代码即可，示例：

//箱子，存量苹果的容器
public class Box {
	//箱子中目前苹果的数量
    int num;
    Lock lock = new ReentrantLock();
    Condition full = lock.newCondition();
    Condition empty = lock.newCondition();

    public void put() {
    	lock.lock();
    	try {
	        try {
	            Thread.sleep(1000);
	        } catch (InterruptedException e) {
	            e.printStackTrace();
	        }
	        
	        //10是箱子中能存放苹果的最大数量
	        while (num == 10) {             
	            try {
	                System.out.println("箱子满了，生产者暂停");
	                //等待消费者消费一个才能继续生产，所以要让出锁
	                full.await();                       
	            } catch (InterruptedException e) {
	                e.printStackTrace();
	            }
	        }
	        
	        num++;
	        System.out.println("箱子未装满，开始生产，生产后箱子中的苹果数量："+num);
	        //唤醒可能因为没苹果而等待的消费者
	        empty.signal(); 
    	}finally {
    		lock.unlock();
		}
    }
    
    public synchronized void take() {
    	lock.lock();
    	try {
	        try {
	            Thread.sleep(1000);
	        } catch (InterruptedException e) {
	            e.printStackTrace();
	        }
	        
	        while (num == 0) {          
	            try {
	                System.out.println("箱子空了，消费者暂停");
	                //等待生产者生产一个才能继续消费,所以要让出锁
	                empty.await();                      
	            } catch (InterruptedException e) {
	                e.printStackTrace();
	            }
	        }
	        
	        num--;
	        System.out.println("箱子中有了苹果，开始消费，消费后箱子中的苹果数量："+num);
	        //唤醒可能因为苹果满了而等待的生产者
	        full.signal();    
    	}finally {
    		lock.unlock();
		}
    }
}

结果示例：

转载:https://blog.csdn.net/m0_37741420/article/details/110225520

大渔歌_
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
多线程基础
m0_54108654的博客
04-16 759
目录 一 线程相关概念 1 程序 2 进程 3 线程 4 单线程 5 多线程 6 并发——交替运行 7 并行——同时运行 二 线程的基本使用 1 创建线程的两种方式 2 线程应用案例1—继承Thread类 3 线程应用案例2—实现Runnable接口 4 线程应用案例3——多线程执行 5 两种创建线程方式的区别 一 线程相关概念 1 程序 定义：是为了完成特定任务，用某种语言编写的一组指令集合 简单的说：就是我们些的代码 2 进程 21 进程就是运行的程序，程序一
java高级特性与实战项目 ——第四章： 多线程
gz98411的博客
05-22 659
1.编写一个程序，创建俩个线程对象，每个线程输出1~5的数。要求线程类分别使用继承Thread类和实现Runnable接口俩种方式创建。public class MyThread1 extends Thread{ //继承 @Override public void run() { //重写方法 // TODO Auto-generated method stub for (in...
java多线程作业.docx
06-29
Java语言的一大特性点就是内置对多线程的支持。多线程是指一个应用程 序中同时存在几个执行体,按几条不同的执行线索共同工作的情况,它使得编 微课视频 程人员可以很方便地开发出具有多线程功能、能同时处理多个任务的功能强大 的应用程序。虽然执行线程给人一种几个事件同时发生的感觉,但这只是一种错觉,因为我们的计算机在任何给定的时刻只能执行那些线程中的一个。为了建立这些线程正在同步执行的感觉,Java虚拟机快速地把控制从一个线程切换到另一个线程。这些线程将被轮流执行,使得每个线程都有机会使用CPU资源。
牛客刷题笔记--并发
想握住此生辽阔
07-06 3684
1 下面关于并行和并发的区别，说法错误的是？（C） 并发计算是一种程序计算的形式，在系统中，至少有两个以上的计算在同时运作，计算结果可能同时发生 并行计算指许多指令得以同时进行的计算模式。在同时进行的前提下，可以将计算的过程分解成小部份，之后以并发方式来加以解决 并行是同时发生的多个并发事件，并发事件之间一定要同一时刻发生 并发是逻辑上的同时发生（simultaneous），而并行是物理上的同时发生 答： 并发和并行的区别就是一个处理器同时处理多个任务和多个处理器或者是多核的处理器同时处理多个不同的任务。
并发编程笔记(2)
qq_41775321的博客
07-02 300
四．共享模型之内存 1、Java 内存模型（JMM） JMM 即 Java Memory Model，它定义了主存（共享内存）、工作内存（线程私有）抽象概念，底层对应着 CPU 寄存器、缓存、硬件内存、 CPU 指令优化等。 JMM 体现在以下几个方面 原子性 - 保证指令不会受到线程上下文切换的影响 可见性 - 保证指令不会受 cpu 缓存的影响 有序性 - 保证指令不会受 cpu 指令并行优化的影响 2、可见性 1）退不出的循环 解决方法 使用...
多线程编程例子
Pop_Rain的博客
03-11 645
title: 多线程编程例子 date: 2019-10-1 19:00:08 updated: 2020-02-27 19:04:06 categories: 多线程 tags: - 多线程 本博文记录多线程编程的几个案例，包含了常见的几种多线程编程套路。 1.四个线程计算1到100的求和 1.依次调用thread.join()，主线程输出结果。注意：sum为共享变量，访问共享变量时，用s...
多线程编程示例（1）
qq_41617901的博客
07-14 118
public void LoadData() { if (_jbxx != null) { string addr = ConfigurationManager.AppSettings["ServiceAddr"].ToString(); //去掉地址结尾的'/',否则请求中会出现两个'/'，而导致请求失败 string url = strin...
多线程编程示例
02-25
在IT领域，多线程编程是一项关键技能，尤其是在性能优化和并发处理方面。本文将深入探讨多线程编程的基础知识，以帮助初学者快速入门。 首先，我们需要理解什么是多线程。多线程是指在一个进程中同时执行多个独立的...
c语言多线程编程使用示例
09-04
下面是一个简单的C语言多线程编程示例： ```c #include #include #include #define THREAD_NUM 10 void *test(void *args) { printf("tid %d: i say 'Hello'.\n", args); return NULL; } int main() { int...
Linux下的多线程编程实例解析
09-14
【Linux下的多线程编程实例解析】 在计算机操作系统中，多线程编程是实现并行处理和提高系统效率的一种重要技术。Linux系统同样支持多线程编程，这使得开发者能够利用这一特性创建高效的、响应迅速的应用程序。多...
Java多线程详解及示例
07-20
Java多线程编程是提升程序性能和响应性的关键技术。理解多线程的概念，掌握线程的创建、同步、通信、死锁避免等核心知识点，以及合理使用线程池，对于编写高效、稳定的并发程序至关重要。通过实践，开发者可以更好地...
多线程编程10例
05-06 943
进程和线程都是操作系统的概念。进程是应用程序的执行实例，每个进程是由私有的虚拟地址空间、代码、数据和其它各种系统资源组成，进程在运行过程中创建的资源随着进程的终止而被销毁，所使用的系统资源在进程终止时被释放或关闭。线程是进程内部的一个执行单元。系统创建好进程后，实际上就启动执行了该进程的主执行线程，主执行线程以函数地址形式，比如说main或WinMain函数，将程序的启动点提供给Windows系统。主执行线程终止了，进程也就随之终止。
多线程学习之多线程的案例
最新发布
m0_62314761的博客
08-29 789
需求：有100份礼品,两人同时发送，当剩下的礼品小于10份的时候则不再送出。利用多线程模拟该过程并将线程的名字和礼物的剩余数量打印出来.
多线程编程作业-买票
远坂凛大小姐
04-21 593
作业要求： 1、 假设现在有一个售票员进行售票，票价为5元，初始状态：票数不限，票售员手中有1张10元钱； 2、 每来一个顾客买票，相当于是创建一个线程，注意，此时顾客共享的资源是售票员及其手中的钱； 3、 当一个顾客到达后相当于创建一个线程，创建该线程时有两个参数，一是线程名，也就是顾客的名字，二是顾客带的钱（规定顾客带的钱只能为5元，10元，20元和50元）。 4、 某一个顾客买票时，如果售票员无法找零，则让该顾客等待，如果某一个顾客买票成功，则唤醒所有等待的顾客。 5、 主线程中用一个死循环来实现持续
多线程编程题
weixin_53812805的博客
05-03 438
举例一：子线程循环3次，接着主线程循环6次，接着又回到子线程循环3次，接着再回到主线程又循环6次，如此循环50次，试写出代码。 #include <stdio.h> #include <pthread.h> #include <stdlib.h> #include <unistd.h> int flag = 0; int count = 0; void *function(void *arg) { while (1) { ...
多线程经典案例
qq_54219272的博客
06-25 4414
多线程的单例模式，定时器，线程池的实现等
c++多线程编程：常见面试题
weixin_30919919的博客
10-11 1045
题目：子线程循环10次，接着主线程循环100次，接着又回到子线程循环10次，接着再回到主线程又循环100次，如此循环50次，试写出代码 子线程与主线程必有一个满足条件(flag == num),不满足条件的那个线程不可能获取unique_lock(会在wait中释放)，只有满足条件的线程才能获取锁，执行程序 mutex m;//保护条件的互斥访问 condition_va...
多线程问题
『程序员·小李』的博客
05-26 186
多线程的使用示例 package com.jdojo.threads; public class MultiPrinterThread { public static void main(String[] args) { // Create two Thread objects Thread t1 = new Thread(MultiPrinterThread::print); Thread t2 = new
【转】用信号量(互斥锁)实现两个线程交替打印
tecoes的博客
05-11 838
转载自https://blog.csdn.net/liqiao_418/article/details/83715863，面试的时候被问到了怎么交替打印数字通过两个线程，当时有点懵，知道考察的点是线程的同步和线程互斥，能想到的也是互斥锁和条件变量，但是具体怎么实现当时却没有想到，网上搜索了一下，发现这篇文章通过互斥锁和信号量来实现，最关键的还想到了使用两个标志位的小技巧来处理各种异常情况，考虑的非常细致。 本文实现两个线程交替打印，采用的是逐步添加代码，分析每一步代码的作用，若想要看最终版本可直接翻看后面

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值