多线程合并练习题，线程安全（售票任务引入）--学习JavaEE的day30

最新推荐文章于 2024-06-19 20:41:10 发布

2401_84281729

最新推荐文章于 2024-06-19 20:41:10 发布

阅读量563

点赞数 6

分类专栏：程序员文章标签：网络安全学习面试

本文链接：https://blog.csdn.net/2401_84281729/article/details/138811263

版权

程序员专栏收录该内容

166 篇文章 1 订阅

订阅专栏

写在最后

在结束之际，我想重申的是，学习并非如攀登险峻高峰，而是如滴水穿石般的持久累积。尤其当我们步入工作岗位之后，持之以恒的学习变得愈发不易，如同在茫茫大海中独自划舟，稍有松懈便可能被巨浪吞噬。然而，对于我们程序员而言，学习是生存之本，是我们在激烈市场竞争中立于不败之地的关键。一旦停止学习，我们便如同逆水行舟，不进则退，终将被时代的洪流所淘汰。因此，不断汲取新知识，不仅是对自己的提升，更是对自己的一份珍贵投资。让我们不断磨砺自己，与时代共同进步，书写属于我们的辉煌篇章。

需要完整版PDF学习资源私我

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化资料的朋友，可以点击这里获取

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！

// }

// public boolean isFlag() {
// return flag;
// }


#### 使用任务类



> 
> 任务类更容易理解，线程合并，分拆了多个线程来进行并行计算，2万个整数分成几段
> 
> 
>  //创建任务  
>   Task task1 = new Task(0, 5000, arr);  
>   Task task2 = new Task(5000, 10000, arr);  
>   Task task3 = new Task(10000, 15000, arr);  
>   Task task4 = new Task(15000, 20000, arr);
> 
> 
>

public class Task implements Runnable{

private int startIndex;
private int endIndex;
private int[] arr;

public Task(int startIndex, int endIndex, int[] arr) {
	this.startIndex = startIndex;
	this.endIndex = endIndex;
	this.arr = arr;
}

private int sum;
private boolean flag = true;

@Override
public void run() {
	for (int i = startIndex; i < endIndex; i++) {
		sum += arr[i];
	}
	
	flag = false;
}

public int getSum() {
	return sum;
}

public boolean isFlag() {
	return flag;
}

}

public class Test01 {
public static void main(String[] args) throws InterruptedException {

	//创建数组
	int[] arr = new int[20000];
	
	//初始化数组数据 -- {1,2,3,....,20000}
	for (int i = 0; i < arr.length; i++) {
		arr[i] = i+1;
	}
	
	//创建任务
	Task task1 = new Task(0, 5000, arr);
	Task task2 = new Task(5000, 10000, arr);
	Task task3 = new Task(10000, 15000, arr);
	Task task4 = new Task(15000, 20000, arr);
	
	//创建线程
	Thread t1 = new Thread(task1);
	Thread t2 = new Thread(task2);
	Thread t3 = new Thread(task3);
	Thread t4 = new Thread(task4);
	
	//启动线程
	t1.start();
	t2.start();
	t3.start();
	t4.start();
	
	//问题出现原因：四个子线程还没有运行完毕，就被主线程抢到CPU资源了
	//解决思路：让四个子线程执行完毕后，主线程才能执行 --- 主线程阻塞！！！
	
	//解决方案一：

// Thread.sleep(6);缺点：休眠不知道设置多少好

	//解决方案二：

// while(task1.isFlag() || task2.isFlag() || task3.isFlag() || task4.isFlag()){}
// 缺点：主线程会抢到资源，只是条件原因而不会结束

	//解决方案三：
	t1.join();
	t2.join();
	t3.join();
	t4.join();
	
	//合并任务的运行结果
	int result = task1.getSum() + task2.getSum() + task3.getSum() + task4.getSum();
	System.out.println(result);
}

}


#### 注意：



> 
> 主线程结束，子线程还会继续执行完成
> 
> 
> 


### 2.售票任务（线程安全）



> 
> 2.铁道部发布了一个售票任务，要求销售1000张票，要求有3个窗口来进行销售，请编写多线程程序来模拟这个效果（该题涉及到线程安全，https://www.jb51.net/article/221008.htm）
> 
> 
> i. 窗口001正在销售第1张票
> 
> 
> ii. 窗口001正在销售第2张票
> 
> 
> iii. 窗口002正在销售第3张票
> 
> 
> iv. 。。。
> 
> 
> v. 窗口002正在销售第1000张票
> 
> 
> 涉及到线程安全，要加锁
> 
> 
> 


#### 使用线程类

public class MyThread extends Thread{

private static int allTicket = 1000;
private static int curTicket = 0;
private static Object obj = new Object();

public MyThread(String name) {
	super(name);
}

@Override
public void run() {
	
	while(curTicket < allTicket){
		//synchronized (String.class) {
		//synchronized ("abc") {
		
		synchronized (obj) {
			if(curTicket < allTicket){
				curTicket++;
				System.out.println("窗口" + Thread.currentThread().getName() + "正在销售第" + curTicket + "张票");
			}
			if(curTicket >= allTicket){
				System.out.println("窗口" +  Thread.currentThread().getName() + "票已经售完");
			}
		}
		
	}
	
}

}

public class Test01 {

public static void main(String[] args) {
	
	MyThread t1 = new MyThread("001");
	MyThread t2 = new MyThread("002");
	MyThread t3 = new MyThread("003");
	
	t1.start();
	t2.start();
	t3.start();
	
}

}


##### 模拟过程出现问题


###### 问题一：



> 
> 三个窗口各卖1000张票，一共卖了3000张
> 
> 
> 出现原因：allTicket和curTicket是run方法的局部变量，三个线程抢到CPU资源后，都会调用run方法，run方法被调用了3次，所以卖了3000张票
> 
> 
> 解决方案：将allTicket和curTicket设置为静态变量，让三个线程共享
> 
> 
> 


###### 出现原因：

public class MyThread extends Thread{

public MyThread(String name) {
	super(name);
}

@Override
public void run() {
	
    int allTicket = 1000;
	int curTicket = 0;
	while(curTicket < allTicket){
		
		curTicket++;
		System.out.println("窗口" + Thread.currentThread().getName() + "正在销售第" + curTicket + "张票");
	}
}

}


###### 解决方案：

public class MyThread extends Thread{

private static int allTicket = 1000;
private static int curTicket = 0;

public MyThread(String name) {
	super(name);
}

@Override
public void run() {

	while(curTicket < allTicket){
		
		curTicket++;
		System.out.println("窗口" + Thread.currentThread().getName() + "正在销售第" + curTicket + "张票");
	}
}

}


###### 问题二：



> 
> 有些票没有卖，有些票卖了重票
> 
> 
> 出现原因：当前线程抢到CPU资源后做了票的自增，但是还没来得及输出，时间片到了就退出CPU资源，然后其他线程抢到CPU资源了
> 
> 
> 解决方案：当前线程抢到CPU资源后，票的自增和输出执行完毕才能切换到其他线程运行 – 加锁
> 
> 
> 


###### 出现原因

public class MyThread extends Thread{

private static int allTicket = 1000;
private static int curTicket = 0;

public MyThread(String name) {
	super(name);
}

@Override
public void run() {

// 举例：
// curTicket - 0 -1-2-3…
while(curTicket < allTicket){
// 线程t1抢到资源，调用run(),curTicket++变成1，还没来得及输出，时间片到了，退出cpu资源
// 线程t3抢到资源，调用run(),curTicket++变成2，还没来得及输出，时间片到了，退出cpu资源
// 线程t2抢到资源，调用run(),curTicket++变成3，输出正在销售第3张，时间片到了，退出cpu资源
// 线程t1抢到资源，输出正在销售第3张票，时间片到了，退出cpu资源
// 线程t3抢到资源，输出正在销售第3张票，时间片到了，退出cpu资源
curTicket++;
System.out.println(“窗口” + Thread.currentThread().getName() + “正在销售第” + curTicket + “张票”);
}
}
}


###### 解决方案

public class MyThread extends Thread{

private static int allTicket = 1000;
private static int curTicket = 0;

// private Object obj = new Object();第三种new（锁）对象
// 注意：成员变量时，new了三次，三个对象，三把锁，没有锁住
// 设置成静态的，设置成静态变成一把锁（对象）才锁的住
private static Object obj = new Object();

public MyThread(String name) {
	super(name);
}

@Override
public void run() {

// 举例：
// curTicket - 0 -1-2-3…
while(curTicket < allTicket){
//第一种：synchronized (String.class) {任意类的对象在程序中唯一的
//第二种：synchronized (“abc”) {字符串对象放在常量池也是唯一的
synchronized (obj) {//自动上锁

// 线程t1抢到资源，调用run(),自动上锁，curTicket++变成1，还没来得及输出，时间片到了，退出cpu资源
// 线程t3抢到资源，调用run(),有锁，退出
// 线程t2抢到资源，调用run(),有锁，退出
// 线程t1抢到资源，输出正在销售第3张票，自动解锁，时间片到了，退出cpu资源
// 线程t3抢到资源…
curTicket++;
System.out.println(“窗口” + Thread.currentThread().getName() + “正在销售第” + curTicket + “张票”);
}//自动解锁
}
}
}


###### 问题三：



> 
> 多卖了票
> 
> 
> 出现原因：curTicket到了临界点（999），三个线程都可以进判断，然后上锁
> 
> 
> 解决方案：在锁中再次判断
> 
> 
> 


###### 出现原因：

public class MyThread extends Thread{

private static int allTicket = 1000;
private static int curTicket = 0;
private static Object obj = new Object();

public MyThread(String name) {
	super(name);
}

@Override
public void run() {

// 临界值：
// curTicket - 999
while(curTicket < allTicket){

        synchronized (obj) {//自动上锁

// 线程t1抢到资源，调用run(),还没有上锁，挂起

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化资料的朋友，可以点击这里获取

2401_84281729

关注

6
点赞
踩
12

收藏

觉得还不错? 一键收藏
0
评论
多线程合并练习题，线程安全（售票任务引入）--学习JavaEE的day30

在结束之际，我想重申的是，学习并非如攀登险峻高峰，而是如滴水穿石般的持久累积。尤其当我们步入工作岗位之后，持之以恒的学习变得愈发不易，如同在茫茫大海中独自划舟，稍有松懈便可能被巨浪吞噬。然而，对于我们程序员而言，学习是生存之本，是我们在激烈市场竞争中立于不败之地的关键。一旦停止学习，我们便如同逆水行舟，不进则退，终将被时代的洪流所淘汰。因此，不断汲取新知识，不仅是对自己的提升，更是对自己的一份珍贵投资。让我们不断磨砺自己，与时代共同进步，书写属于我们的辉煌篇章。需要完整版PDF学习资源私我。
复制链接

扫一扫