奇数偶数分离_多线程的意义

最新推荐文章于 2023-07-09 00:13:07 发布
最新推荐文章于 2023-07-09 00:13:07 发布
阅读量293 收藏
点赞数
分类专栏： 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_25986811/article/details/79834824
版权
要求： 给个list 进行奇数偶数分开，list中有1-20，20个数字。

每获得一个数字之后等待5秒，用来模拟根据这个数字进行的其他操作之后入库。（该操作与数组没有关系）

单线程：for循环 ????

package getList;

import java.util.ArrayList;
import java.util.List;

public class ForGetListNum {
	public static void main(String[] args) {
		long startTime = System.currentTimeMillis(); 
		int []lists = new int[]{1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20};
		List<Integer> getLists_ou = new ArrayList<Integer>();
		List<Integer> getLists_ji = new ArrayList<Integer>();
		for (int i = 0 ; i<lists.length;i++){
			if (lists[i]%2 == 0){
				try {
					System.out.println("线程 "+ Thread.currentThread().getName()+"--模拟5秒等待中...");
					Thread.sleep(5000);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
				getLists_ou.add(lists[i]);
				System.out.println("线程 "+ Thread.currentThread().getName()+"------获取元素：  "+lists[i]);
			}else{
				try {
					System.out.println("线程 "+ Thread.currentThread().getName()+"--模拟5秒等待中...");
					Thread.sleep(5000);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
				getLists_ji.add(lists[i]);
				System.out.println("线程 "+ Thread.currentThread().getName()+"------获取元素：  "+lists[i]);
			}
		}
		System.out.println("  ");  
		System.out.println("线程 "+ Thread.currentThread().getName()+"  偶数集合："+getLists_ou.toString()+"集合长度："+getLists_ou.size());
		System.out.println("线程 "+ Thread.currentThread().getName()+"  奇数集合："+getLists_ji.toString()+"集合长度："+getLists_ji.size());
		long endTime = System.currentTimeMillis();  
		float seconds = (endTime - startTime) / 1000F;  
		System.out.println("  ");  
		System.out.println("                                for循环共耗时：       "+Float.toString(seconds) + " seconds.");  

	}
}

打印：

线程 main------模拟5秒等待中...
线程 main------获取元素：  1
线程 main------模拟5秒等待中...
线程 main------获取元素：  2
线程 main------模拟5秒等待中...
线程 main------获取元素：  3
线程 main------模拟5秒等待中...
线程 main------获取元素：  4
线程 main------模拟5秒等待中...
线程 main------获取元素：  5
线程 main------模拟5秒等待中...
线程 main------获取元素：  6
线程 main------模拟5秒等待中...
线程 main------获取元素：  7
线程 main------模拟5秒等待中...
线程 main------获取元素：  8
线程 main------模拟5秒等待中...
线程 main------获取元素：  9
线程 main------模拟5秒等待中...
线程 main------获取元素：  10
线程 main------模拟5秒等待中...
线程 main------获取元素：  11
线程 main------模拟5秒等待中...
线程 main------获取元素：  12
线程 main------模拟5秒等待中...
线程 main------获取元素：  13
线程 main------模拟5秒等待中...
线程 main------获取元素：  14
线程 main------模拟5秒等待中...
线程 main------获取元素：  15
线程 main------模拟5秒等待中...
线程 main------获取元素：  16
线程 main------模拟5秒等待中...
线程 main------获取元素：  17
线程 main------模拟5秒等待中...
线程 main------获取元素：  18
线程 main------模拟5秒等待中...
线程 main------获取元素：  19
线程 main------模拟5秒等待中...
线程 main------获取元素：  20
  
线程 main  偶数集合：[2, 4, 6, 8, 10, 12, 14, 16, 18, 20]集合长度：10
线程 main  奇数集合：[1, 3, 5, 7, 9, 11, 13, 15, 17, 19]集合长度：10
  
                                for循环共耗时：       100.008 seconds.


=======================================================================

多线程：

思路：开list.length个线程。

package getList;

import java.util.ArrayList;


public class MainClass {

	/**
	 * 要求： 给个list 进行奇数偶数分开，list中有1-20，20个数字。
		每获得一个数字，需要等待5秒，模拟根据这个数字进行的其他操作。（该操作与数组没有关系）
	 * @author yiyitadiedie
	 *
	 */
	public static void main(String[] args) throws InterruptedException {
		long startTime = System.currentTimeMillis(); 

		Lists lists = new Lists();

		ArrayList<AddNum> addNumList = new ArrayList<AddNum>();
		ArrayList<Thread> threadList = new ArrayList<Thread>();

		for (int i =0 ;i< lists.lists.length; i++){
			AddNum addNum = new AddNum(lists);
			addNumList.add(addNum);
		}
		for (int i =0 ;i<addNumList.size(); i++){
			Thread t = new Thread(addNumList.get(i));
			threadList.add(t);
		}
		for (Thread t :threadList)
			t.start();

		for (Thread t :threadList)
			t.join();

		System.out.println("  ");  
		System.out.println("线程 "+ Thread.currentThread().getName()
				+"  偶数集合："+lists.getLists_ou.toString()+"集合长度："
				+lists.getLists_ou.size());
		System.out.println("线程 "+ Thread.currentThread().getName()
				+"  奇数集合："+lists.getLists_ji.toString()+"集合长度："
				+lists.getLists_ji.size());
		long endTime = System.currentTimeMillis();  
		float seconds = (endTime - startTime) / 1000F;  
		System.out.println("  ");  
		System.out.println("                        多线程 共耗时：       "
				+Float.toString(seconds) + " seconds.");  
	}
}


package getList;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
/**
 * 待校验数组
 * @author yiyitadiedie
 *			数组lists 、getLists 模拟两张数据库表
 *			模拟5秒查询时间，得到数组中的NUM，模拟添加NUM到另一个数组
 *
 *			使用多线程的目的：每个数组元素获得之后的查询动作可以同时进行，后一个元素的查询与上一个元素查询不需要同步。
 *							即：通过多线程将这部分查询时间同时进行。
 */
public class Lists {
	/**
	 * 需要考虑同步元素
	 * 
	 * 	1. 数组本身的所有元素。			 			-------> 进程初始化载入。
	 * 					
	 * 	2. 取元素的过程同步。							-------> lock_get
	 * 			每个线程取值的下标，可以用数组的长度  - 取过的次数
	 * 					长度			：通过数组本身.length获得；
	 * 					取过的次数 	：run方法调用Lists 中的方法计数，下一个线程从Lists中获得该数。
	 * 
	 * 	3. 插入元素要同步。							-------> lock_set
	 *   插入偶数、奇数两个数组不需要同步，    --------->lock_set_ou、lock_set_ji
	 * 			如果在某个瞬间，两个进程都在往数组中插入时，就可能会产生数据丢失。
	 * 			（如果多个线程进行同一个数组插入元素操作时，必须同步。只有一个线程对一个数组插入时，不需要。）
	 * 			（数据库入库也一样，如果不等前一个insert进入，后一个insert插入，主键唯一校验就无法保证。）	
	 */
	Lock lock_get = new ReentrantLock();				// 获得元素的锁
	Lock lock_set_ou = new ReentrantLock();				// 添加偶数元素的锁
	Lock lock_set_ji = new ReentrantLock();				// 添加偶数元素的锁
	// 过滤前的数组
	int []lists  = new int[]
			{  	1, 2, 3, 4, 5, 6, 7, 8, 9,10,
			11,12,13,14,15,16,17,18,19,20};
	// 按过滤规则过滤后的存放的数组
	int getNumLength = 0;  // 每放入一个数，++一次，即 getNumLength == lists.length -1;
	List<Integer> getLists_ou = new ArrayList<Integer>(); // 放入偶数
	List<Integer> getLists_ji = new ArrayList<Integer>(); // 放入奇数
	
	public int getNum(){
		lock_get.lock();
		int i = 0;
		if (getNumLength<lists.length){//getNumLength == lists.length -1
			i = lists[getNumLength];
			getNumLength++;
			System.out.println("线程 "
			+ Thread.currentThread().getName()
			+"------获取元素：  "+i);
		}
		return i;
	}
	public void setOuNum(int Num){
		lock_set_ou.lock();
		getLists_ou.add(Num);
		System.out.println("线程 "
		+ Thread.currentThread().getName()+"-------添加完成！");
		lock_set_ou.unlock();
	}
	public void setJiNum(int Num){
		lock_set_ji.lock();
		getLists_ji.add(Num);
		System.out.println("线程 "
		+ Thread.currentThread().getName()+"-------添加完成！");
		lock_set_ji.unlock();
	}
}

package getList;

public class AddNum implements Runnable{
	private Lists lists;
	AddNum(Lists lists){
		this.lists = lists;
	}
	private int i =0;// 获取的元素
	private int threadNo1 = 0;// 获取元素后，是否完成塞值的标记。
	public void run() {
		A:while(true){
			while(lists.lists.length == lists.getNumLength){// 获取全部元素后关闭线程
				System.out.println("线程 "
						+ Thread.currentThread().getName()+" ----------------关闭" );
				break A;
			}
			while(threadNo1 ==0){
				threadNo1 = 1;
				i = lists.getNum();
				lists.lock_get.unlock();// 获得元素后，释放锁
				if(i%2==0&&i!=0){
					System.out.println("线程 "
							+ Thread.currentThread().getName()+"------模拟5秒等待中...");
					try { Thread.sleep(5000); 
					} catch (InterruptedException e) {
						e.printStackTrace();
					}				
					lists.setOuNum(i);
					threadNo1 = 0;// 完成塞值动作
				}else if(i!=0){
					System.out.println("线程 "
							+ Thread.currentThread().getName()+"------模拟5秒等待中...");
					try { Thread.sleep(5000); 
					} catch (InterruptedException e) {
						e.printStackTrace();
					}	
					lists.setJiNum(i);
					threadNo1 = 0;
				}
			}
		}
	}
}





打印：

线程 Thread-0------获取元素：  1
线程 Thread-1------获取元素：  2
线程 Thread-1------模拟5秒等待中...
线程 Thread-2------获取元素：  3
线程 Thread-0------模拟5秒等待中...
线程 Thread-2------模拟5秒等待中...
线程 Thread-4------获取元素：  4
线程 Thread-4------模拟5秒等待中...
线程 Thread-5------获取元素：  5
线程 Thread-5------模拟5秒等待中...
线程 Thread-6------获取元素：  6
线程 Thread-6------模拟5秒等待中...
线程 Thread-8------获取元素：  7
线程 Thread-8------模拟5秒等待中...
线程 Thread-9------获取元素：  8
线程 Thread-9------模拟5秒等待中...
线程 Thread-10------获取元素：  9
线程 Thread-10------模拟5秒等待中...
线程 Thread-11------获取元素：  10
线程 Thread-11------模拟5秒等待中...
线程 Thread-14------获取元素：  11
线程 Thread-14------模拟5秒等待中...
线程 Thread-16------获取元素：  12
线程 Thread-16------模拟5秒等待中...
线程 Thread-17------获取元素：  13
线程 Thread-17------模拟5秒等待中...
线程 Thread-18------获取元素：  14
线程 Thread-18------模拟5秒等待中...
线程 Thread-3------获取元素：  15
线程 Thread-3------模拟5秒等待中...
线程 Thread-13------获取元素：  16
线程 Thread-13------模拟5秒等待中...
线程 Thread-7------获取元素：  17
线程 Thread-7------模拟5秒等待中...
线程 Thread-12------获取元素：  18
线程 Thread-12------模拟5秒等待中...
线程 Thread-15------获取元素：  19
线程 Thread-15------模拟5秒等待中...
线程 Thread-19------获取元素：  20
线程 Thread-19------模拟5秒等待中...
线程 Thread-1-------添加完成！
线程 Thread-1 ----------------关闭
线程 Thread-2-------添加完成！
线程 Thread-2 ----------------关闭
线程 Thread-4-------添加完成！
线程 Thread-4 ----------------关闭
线程 Thread-0-------添加完成！
线程 Thread-9-------添加完成！
线程 Thread-9 ----------------关闭
线程 Thread-8-------添加完成！
线程 Thread-8 ----------------关闭
线程 Thread-5-------添加完成！
线程 Thread-5 ----------------关闭
线程 Thread-6-------添加完成！
线程 Thread-17-------添加完成！
线程 Thread-17 ----------------关闭
线程 Thread-11-------添加完成！
线程 Thread-11 ----------------关闭
线程 Thread-16-------添加完成！
线程 Thread-16 ----------------关闭
线程 Thread-13-------添加完成！
线程 Thread-13 ----------------关闭
线程 Thread-6 ----------------关闭
线程 Thread-0 ----------------关闭
线程 Thread-10-------添加完成！
线程 Thread-10 ----------------关闭
线程 Thread-14-------添加完成！
线程 Thread-14 ----------------关闭
线程 Thread-18-------添加完成！
线程 Thread-18 ----------------关闭
线程 Thread-3-------添加完成！
线程 Thread-3 ----------------关闭
线程 Thread-19-------添加完成！
线程 Thread-19 ----------------关闭
线程 Thread-15-------添加完成！
线程 Thread-15 ----------------关闭
线程 Thread-12-------添加完成！
线程 Thread-12 ----------------关闭
线程 Thread-7-------添加完成！
线程 Thread-7 ----------------关闭
  
线程 main  偶数集合：[2, 4, 8, 6, 10, 12, 16, 14, 20, 18]集合长度：10
线程 main  奇数集合：[3, 1, 7, 5, 13, 9, 11, 15, 19, 17]集合长度：10
  
                                 多线程 共耗时：       5.017 seconds.


qq_25986811
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【Java多线程】JUC之线程池(四)ForkJoin
墩墩分墩
03-21 916
Fork/Join框架是`Java7`提供的一个用于`并行执行任务`的框架，可以把`大任务分割成若干个小任务`，`最终汇总每个小任务结果后得到大任务结果的框架`。 可以通过Fork和Join这两个单词来理解下Fork/Join框架 - **Fork**就是把一个`大任务` `切分` 为`若干子任务并行的执行` - **Join**就是`合并这些子任务的执行结果`，最后得到这个`大任务的结果`。
SpringBoot+ShardingJDBC实现读写分离、分库分表
weixin_70730532的博客
06-24 668
最早是当当网内部使用的一款分库分表框架，到2017年的时候才开始对外开源，这几年在大量社区贡献者的不断迭代下，功能也逐渐完善，现已更名为 ，2020年4⽉16日正式成为 Apache 软件基金会的顶级项目。ShardingSphere-Jdbc定位为轻量级Java框架，在Java的Jdbc层提供的额外服务。它使用客户端直连数据库，以jar包形式提供服务，可理解为增强版的Jdbc驱动，完全兼容Jdbc和各种ORM框架。 随着版本的不断更迭 ShardingSphere 的核心功能也变得多元化起来。从最开始 S
线程交替打印奇偶数（信号量Semaphore实现）
hello world
03-17 2467
实现方法一，信号量 思路： 两个线程都持有相同的一个信号量，奇数线程启动，获取信号量，然后打印完，释放信号量，再休眠，然后偶数线程启动，获取信号量，然后打印完，释放信号量 package demo6; import java.util.concurrent.Semaphore; /** * @ClassName AlternatePrinting * @Author laixiaoxing...
多线程20个奇偶数一组交替打印
iteye_13327的博客
04-01 209
问题描述： 多线程打印20个偶数20个奇数为一组交替打印； /** * 多线程打印 * 先打印20个偶数在打印20个奇数依次循环交替 * @author dongfen * */ public class EOdd { public static void main(String[] args) { Num1 num = new Num1(1000); Threa...
多线程实现奇偶数交替输出
qq_48967079的博客
07-28 493
多线程实现奇偶数交替输出 public class ThreadText19 { public static void main(String[] args) { Num num=new Num();//实例化Num对象 Thread thread=new Thread(new Runnable() {//创建线程 public void run() { while (num.i<101){//循环
多线程循环打印奇数和偶数
Ares的专栏
02-01 616
多线程循环打印奇数和偶数面试阿里遇到的题目思路具体代码 面试阿里遇到的题目 面试阿里，需要在线做题。第一题就是循环打印的题目。具体题目为两个线程，一个打印奇数，一个打印偶数。 思路 直观的思路是，用reentrantLock，然后还有Condition来实现线程的协作。但是面试官也问到有没有无锁算法。这里既然是无锁算法，那肯定要采用cas这些了，因此直接用atomic类来实现就好了。 具体代码 public class Interview { static volatile AtomicInteger c
用Java实现多线程打印奇偶数
机械工程跑路哥
02-19 2218
多线程小题，使用到synchronized同步锁和wait()、notify() 指令
多线程终极模式：生产者-消费者模式
葵花田
01-02 384
多线程de小事情 导航不迷路： 程序、进程以及线程的爱恨情仇 最简单实现多线程的方法（Thread) 简单易懂的多线程(通过实现Runnable接口实现多线程) 常用获取线程基本信息的方法（新手专属） 多线程，你觉得你安全了？（线程安全问题） 多线程别怕，有锁就安全；（解决线程安全问题） 锁用不好，可能把自己锁住哦！（解决多线程的死锁问题） 文章目录多线程de小事情前言生产者-消费者模式小科普一、何为生产者二、何为消费者三、缓冲区设置缓冲区的三大优点：代码总结随便说说： 前言 在多线程中，我们经
SpringBoot + Sharding JDBC 读写分离、分库分表
m0_67322837的博客
09-01 656
*** @date 2022年06月19日 10:45*/@Data}/*** @date 2022年06月19日 10:45*/}}}/*** @date 2022年06月19日 10:46*/@Mapper}
【C++】C++11之线程库
最新发布
须知少日拏云志，曾许人间第一流。
07-09 541
本文将介绍以下内容：thread类、锁mutex、锁的RAII机制和条件变量condition_variable。
数组遍历，奇数在前，偶数在后
03-27
调整数组中数字的顺序，使得奇数位于数组的前半部分，偶数位于后半部分
10072---多线程交替打印奇偶数
xxxcyzyy的博客
08-10 584
public class PrintOdd implements Runnable { private int i = 1; @Override public void run() { synchronized (this) { while (i <= 10) { if (i%2 != 0) { try { CM.ptl(i); i++;
多线程实现奇偶统计v1 - 暴力版
weixin_30709809的博客
04-21 55
1 #include <stdio.h> 2 #include <stdlib.h> 3 #include <time.h> 4 #include "pthread.h" 5 #define BUFFER_SIZE 1600 6 #define OVER (110000) 7 /* 设置一个整数的圆形缓冲区 */ ...
多线程 奇数偶数按序输出 自学自用
叫我阿斌吧
04-08 446
package t3; import java.util.ArrayList; /*计算偶数*/ public class MyThread2 extends Thread { private ArrayList countList = new ArrayList(); int count = 0; public MyThread2(ArrayList
Java实现两个线程交替打印奇偶数
sjhuangx的专栏
05-14 784
使用两个线程分别交替打印奇偶数。 实现思路，通过一个对象锁同步请求，获取锁之后判断当前数字时候为奇数或者偶数，然后使用Object.wait方法释放锁并等待。 public class Main { public static void main(String[] args) { Main main = new Main(); main.test(); } private volatile int count = 0; pu.
奇数偶数线程
酸奶牛的博客
05-22 267
奇数线程 + 偶数线程 依旧是测试 Object 类的wait方法和notify方法 效果：奇数线程输出奇数，偶数线程输出偶数，每次递增 1 代码： /** * 奇数线程 + 偶数线程 */ public class ThreadTest13 { public static void main(String[] args) { Num num = new Num(); Thread t1 = new Thread(new MyThread11(num)
Java 中使用多线程实现 奇数偶数交替使用线程输出
tfel-ypoc
04-13 977
之前看老杜 JavaSE 教程时给的题目, 当时没做出来. 今天重看新版教程时正好看到 synchronized 关键字, 突然想出解决办法了, 做个记录. 思路: 写一个类做数字提供. 写两个线程类分别做奇数输出和偶数输出. 这两个类都会带一个 数字提供类 的实例. 主方法中构造一个数字提供对象, 和两个以此数字提供对象为构造参数的线程类对象. 代码实现: pa...
Java 多线程中两个线程交替执行，一个输出偶数，一个输出奇数
YHY的日常
08-30 534
1、sync class ThreadPrintDemo2 { public static void main(String[] args) { final ThreadPrintDemo2 demo2 = new ThreadPrintDemo2(); Thread t1 = new Thread(demo2::print1); Thread t2 = new Thread(demo2::print2); t1.start(); t2.start(); }
两个线程分别打印0-100的之间的奇偶数（两种方式对比）
热门推荐
xiongyouqiang的博客
03-11 1万+
业务描述 前段时间遇到一个题目，关于两个线程分别打印0-100的之间的奇偶数，当时自己的写法是通过synchronized同步锁结合wait 和notify 的方式进行编写。主要逻辑的代码如下所示： package com.xyq.maventest.alibaba; import java.util.concurrent.CountDownLatch; /**** * 两个线程分别...
VC_MFC多线程编程指南：理解与应用
"VC_MFC多线程编程详解" 在Windows环境下，开发多线程应用程序是提高系统响应性和效率的有效手段。本资源主要探讨了如何在VC++ MFC框架下进行多线程编程，以及Win32 API提供的相关支持。 在问题引入部分，通过一个...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值