java——多线程2

最新推荐文章于 2024-06-05 14:36:41 发布
最新推荐文章于 2024-06-05 14:36:41 发布
阅读量152 收藏
点赞数
文章标签： 多线程 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/l04593/article/details/119737871
版权

java——多线程2

1.线程局部变量的共享

1.1共享一个变量的情况

使用Map集合（键值对），key放线程对象，value放共享的数据

代码实现：
package com.dream.thread01;

import java.util.concurrent.ConcurrentHashMap;

public class Test01 {
	
	public static ConcurrentHashMap<Thread, Integer> map = new ConcurrentHashMap<>();
	
	public static void main(String[] args) {
	
		new Thread(new Runnable() {
			@Override
			public void run() {
				int i = 10;
				
				//存数据
				map.put(Thread.currentThread(), i);
				
				A a = new A();
				B b = new B();
				a.println();//10
				b.println();//10
			}
		},"线程1").start();
		
		new Thread(new Runnable() {
			@Override
			public void run() {
				int i = 20;
				
				//存数据
				map.put(Thread.currentThread(), i);
				
				A a = new A();
				B b = new B();
				a.println();//20
				b.println();//20
			}
		},"线程2").start();
		
	}
}

package com.dream.thread01;

public class A {
	
	public void println(){
		Thread thread = Thread.currentThread();
		Integer value = Test01.map.get(thread);
		System.out.println(thread.getName() + "中的A类对象调用了println() -- " + value);
	}

}

package com.dream.thread01;

public class B {
	
	public void println(){
		Thread thread = Thread.currentThread();
		Integer value = Test01.map.get(thread);
		System.out.println(thread.getName() + "中的B类对象调用了println() -- " + value);
	}

}

1.2共享多个变量的情况

创建一个实体类进行存储共享的数据

代码实现：
package com.dream.thread02;

public class A {
	
	public void println(){
		Thread thread = Thread.currentThread();
		Data value = Test01.map.get(thread);
		System.out.println(thread.getName() + "中的A类对象调用了println() -- " + value);
	}

}

package com.dream.thread02;

public class B {
	
	public void println(){
		Thread thread = Thread.currentThread();
		Data value = Test01.map.get(thread);
		System.out.println(thread.getName() + "中的B类对象调用了println() -- " + value);
	}

}

package com.dream.thread02;

//数据包类
public class Data {
	
	private int i;
	private String str;
	
	public Data() {
	}

	public Data(int i, String str) {
		this.i = i;
		this.str = str;
	}

	public int getI() {
		return i;
	}

	public void setI(int i) {
		this.i = i;
	}

	public String getStr() {
		return str;
	}

	public void setStr(String str) {
		this.str = str;
	}

	@Override
	public String toString() {
		return "Data [i=" + i + ", str=" + str + "]";
	}
}

package com.dream.thread02;

import java.util.concurrent.ConcurrentHashMap;

public class Test01 {
	
	public static ConcurrentHashMap<Thread, Data> map = new ConcurrentHashMap<>();
	
	public static void main(String[] args) {

		new Thread(new Runnable() {
			@Override
			public void run() {
				
				Data data = new Data(10,"aaa");
				
				//存数据
				map.put(Thread.currentThread(), data);
				
				A a = new A();
				B b = new B();
				a.println();//10
				b.println();//10
			}
		},"线程1").start();
		
		new Thread(new Runnable() {
			@Override
			public void run() {
				Data data = new Data(20,"bbb");
				
				//存数据
				map.put(Thread.currentThread(), data);
				
				A a = new A();
				B b = new B();
				a.println();//20
				b.println();//20
			}
		},"线程2").start();	
	}
}

1.3共享多个变量的情况 - ThreadLocal

代码实现：
package com.dream.thread03;

//数据包类
public class Data {
	
	private int i;
	private String str;
	
	private Data() {
	}

	private Data(int i, String str) {
		this.i = i;
		this.str = str;
	}
	
	//获取数据包的对象
	public static Data getInstance(int i,String str){
		Data data = Test01.local.get();
		if(data == null){
			data = new Data(i, str);
			Test01.local.set(data);
		}else{
			data.setI(i);
			data.setStr(str);
		}
		return data;
	}

	public int getI() {
		return i;
	}

	public void setI(int i) {
		this.i = i;
	}

	public String getStr() {
		return str;
	}

	public void setStr(String str) {
		this.str = str;
	}

	@Override
	public String toString() {
		return "Data [i=" + i + ", str=" + str + "]";
	}
}

package com.dream.thread03;

public class Test01 {
	
	public static ThreadLocal<Data> local = new ThreadLocal<>();
	
	public static void main(String[] args) {

		new Thread(new Runnable() {
			@Override
			public void run() {
				
				Data data = Data.getInstance(10,"aaa");
				
				//存数据
				local.set(data);
				
				A a = new A();
				B b = new B();
				a.println();//10
				b.println();//10
			}
		},"线程1").start();
		
		new Thread(new Runnable() {
			@Override
			public void run() {
				Data data = Data.getInstance(20,"bbb");
				
				//存数据
				local.set(data);
				
				A a = new A();
				B b = new B();
				a.println();//20
				b.println();//20
			}
		},"线程2").start();
		
	}
}

2.synchronized琐

2.1synchronized同步代码块

需求：
package com.dream.thread04_type01;

public class Test01 {
	
	public static void main(String[] args) {
		/*
		 2.铁道部发布了一个售票任务，要求销售1000张票，要求有3个窗口来进行销售，
		  请编写多线程程序来模拟这个效果
				窗口001正在销售第1000张票
				窗口001正在销售第999张票
				窗口002正在销售第998张票
				。。。
				窗口002正在销售第1张票
				
			问题1：三个窗口都卖了1000张票，一共卖了3000张
			出现原因：三个线程调用三次run方法，就有3*1000张票
			解决方案：三个线程共用同一个票的变量
			
			问题2：有些票卖了重票
			出现原因：票的输出语句输出后，还没有来得及做票的减减，就被其他线程抢到CPU资源了
			解决方案：票的输出语句 和 票的减减必须同时执行完毕后，才能被其他线程抢到CPU资源了 - 加锁
			
			问题3：出现负数
			出现原因： 票到了零界点（ticket=1），三个线程都进入循环中
			解决方案：锁中再判断一次

			锁对象：多个线程要想互斥住，就必须使用同一把锁
		*/
		MyThread t1 = new MyThread("窗口001");
		MyThread t2 = new MyThread("窗口002");
		MyThread t3 = new MyThread("窗口003");
		
		t1.start();
		t2.start();
		t3.start();
		
		
	}
}

package com.dream.thread04_type01;

public class MyThread extends Thread{
	
	private static int ticket = 1000;
	private static Object obj = new Object();
	
	public MyThread(String name) {
		super(name);
	}

	@Override
	public void run() {
		
		while(ticket > 0){
			//synchronized("abc"){
			//synchronized(Character.class){
			synchronized(obj){
				if(ticket > 0){
					System.out.println(Thread.currentThread().getName() + "正在销售第" + ticket + "张票");
					ticket--;
				}
				if(ticket <= 0){
					System.out.println(Thread.currentThread().getName() + "票已售完");
				}
			}
		}
	}
}

2.2synchronized同步方法

package com.dream.thread04_type02;

public class Test01 {
	
	public static void main(String[] args) {
		/*
		 2.铁道部发布了一个售票任务，要求销售1000张票，要求有3个窗口来进行销售，
		 请编写多线程程序来模拟这个效果
				窗口001正在销售第1000张票
				窗口001正在销售第999张票
				窗口002正在销售第998张票
				。。。
				窗口002正在销售第1张票
				
			问题1：三个窗口都卖了1000张票，一共卖了3000张
			出现原因：三个线程调用三次run方法，就有3*1000张票
			解决方案：三个线程共用同一个票的变量
			
			问题2：有些票卖了重票
			出现原因：票的输出语句输出后，还没有来得及做票的减减，就被其他线程抢到CPU资源了
			解决方案：票的输出语句 和 票的减减必须同时执行完毕后，才能被其他线程抢到CPU资源了 - 加锁
			
			问题3：出现负数
			出现原因： 票到了零界点（ticket=1），三个线程都进入循环中
			解决方案：锁中再判断一次
			
			锁对象：多个线程要想互斥住，就必须使用同一把锁
			1.synchronized
				同步代码块：
					synchronized(锁对象){//自动上锁
						...要互斥住的代码...
					}//自动解锁
				同步方法：
					//锁对象：this
					public synchronized void method01(){//自动上锁
						...要互斥住的代码...
					}//自动解锁
					
					//锁对象：类的字节码文件对象
					public static synchronized void method02(){//自动上锁
						...要互斥住的代码...
					}//自动解锁
				
		 */
		
		MyThread t1 = new MyThread("窗口001");
		MyThread t2 = new MyThread("窗口002");
		MyThread t3 = new MyThread("窗口003");
		
		t1.start();
		t2.start();
		t3.start();
		
		
	}
}

package com.dream.thread04_type02;

public class MyThread extends Thread{
	
	private static int ticket = 1000;
	
	public MyThread(String name) {
		super(name);
	}

	@Override
	public void run() {
		
		while(ticket > 0){
			method02();
		}
	}
	
	//锁对象：类的字节码文件对象（MyThread.class）
	public static synchronized void method02(){
		if(ticket > 0){
			System.out.println(Thread.currentThread().getName() + "正在销售第" + ticket + "张票");
			ticket--;
		}
		if(ticket <= 0){
			System.out.println(Thread.currentThread().getName() + "票已售完");
		}
	}
	
	//锁对象：this
	public synchronized void method01(){
		if(ticket > 0){
			System.out.println(Thread.currentThread().getName() + "正在销售第" + ticket + "张票");
			ticket--;
		}
		if(ticket <= 0){
			System.out.println(Thread.currentThread().getName() + "票已售完");
		}
	}
}

3.Lock琐

需求：

package com.dream.thread04_type03;

public class Test01 {
	
	public static void main(String[] args) {
		/**
		 2.铁道部发布了一个售票任务，要求销售1000张票，要求有3个窗口来进行销售，
		 请编写多线程程序来模拟这个效果
				窗口001正在销售第1000张票
				窗口001正在销售第999张票
				窗口002正在销售第998张票
				。。。
				窗口002正在销售第1张票
				
			问题1：三个窗口都卖了1000张票，一共卖了3000张
			出现原因：三个线程调用三次run方法，就有3*1000张票
			解决方案：三个线程共用同一个票的变量
			
			问题2：有些票卖了重票
			出现原因：票的输出语句输出后，还没有来得及做票的减减，就被其他线程抢到CPU资源了
			解决方案：票的输出语句 和 票的减减必须同时执行完毕后，才能被其他线程抢到CPU资源了 - 加锁
			
			问题3：出现负数
			出现原因： 票到了零界点（ticket=1），三个线程都进入循环中
			解决方案：锁中再判断一次
			
			锁对象：多个线程要想互斥住，就必须使用同一把锁
					
			Lock
				Lock lock = new ReentrantLock();
				lock.lock();//手动上锁
				...要互斥住的代码...
				lock.unlock();//手动解锁
				
			synchronized vs Lock
			synchronized：关键字层面上的锁，自动上锁和自动解锁
			Lock：API层面上的锁，手动上锁和手动解锁
		 */
		
		MyThread t1 = new MyThread("窗口001");
		MyThread t2 = new MyThread("窗口002");
		MyThread t3 = new MyThread("窗口003");
		
		t1.start();
		t2.start();
		t3.start();
	}
}

package com.dream.thread04_type03;

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class MyThread extends Thread{
	
	private static int ticket = 1000;
	private static Lock lock = new ReentrantLock();
	
	public MyThread(String name) {
		super(name);
	}

	@Override
	public void run() {
		
		while(ticket > 0){
			lock.lock();//手动上锁
			if(ticket > 0){
				System.out.println(Thread.currentThread().getName() + "正在销售第" + ticket + "张票");
				ticket--;
			}
			if(ticket <= 0){
				System.out.println(Thread.currentThread().getName() + "票已售完");
			}
			lock.unlock();//手动解锁
		}
	}
}
L04593
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Java——多线程编程技术.pdf
12-31
Java——多线程编程技术.pdf
Java多线程基础——Lock类
08-31
Lock类是Java类来提供的功能，丰富的api使得Lock类的同步功能比synchronized的同步更强大。本文对此进行详细介绍，下面跟着小编一起来看下吧
Java多线程系列——-多线程的风险问题
01-08
这篇文章，我想说明一下关于Java多线程中会遇到的几种风险以及它们的 概念 1.死锁: 死锁的含义是指一组线程在执行过程中竞争资源导致的一种阻塞的现象，其原因是其中的每一个线程都在等待仅由该组中其他线程才可以...
JAVA面试题——多线程.docx
06-12
JAVA面试题——多线程
Java进阶学习——Java多线程知识的理解
01-20
Java多线程知识的理解0.前言1.从一道题目引入2.创建线程2.1.继承Thread类2.2.实现Runnable接口3.线程的生命周期4.线程安全4.1.为什么需要线程安全？4.2.如何实现线程安全？5.线程池5.1.为什么需要线程池？5.2.创建...
java环境部署
JiuMeilove的博客
06-04 407
如果你电脑已经下载了 jdk ，那你可以跳过这一步了我这里下载的是java21 你们可以选择自己需要下载的游览进去的页面是这样子的（相比以前这个页面发生很大变化了），可以看见目前 jdk 已经发行到 17 了，jdk 它又分了三个个操作系统，一个是 Linux、一个是 macOS、以及 windows，如果你是在 windows 操作系统上，那当然就下载 windows 对应的 jdk，其次的话就是还会区分你操作系统的处理器是 32 位的还是 64 位的，可以点击 我的电脑 - 属性 查看。
java中Overload和Override的区别
codedadi的博客
06-04 592
当调用Dog对象的makeSound方法时，将执行Dog类中的方法，而不是Animal类中的方法。定义：在子类中，有一个与父类同名、同参数列表、同返回类型（或协变返回类型）的方法，则称子类中的该方法为父类同名方法的重写。子类方法的访问权限不能低于父类方法的访问权限（如父类方法为public，则子类方法也必须是public）。Override（重写）：子类与父类之间，方法名、参数列表和返回类型（或协变返回类型）相同。定义：在同一个类中，方法名相同但参数列表（参数类型、参数数量或参数顺序）不同的多个方法。
JavaScript第九讲：BOM编程
星途码客的博客
06-04 1441
今天星途给大家带来JavaScript倒数第二部分知识：BOM编程，希望对码客们有帮助。
Spring异步任务@Async的默认线程池执行器是如何初始化的
简放视野的专栏
06-03 648
Spring异步任务@Async的默认线程池执行器，是从哪里来？是如何初始化的？ 【结论】异步任务@Async的默认线程池执行器是通过TaskExecutionAutoConfiguration#applicationTaskExecutor自动注入的。
拼图小游戏
lazy_girl_666的博客
06-03 725
把A对象的属性值完全拷贝给B对象，也叫对象拷贝，对象复制。
Java Map接口 - HashMap类
IT深耕十余载，大道之简
06-05 172
当哈希表中的条目数超过容量与负载因子的乘积时，哈希表会重新调整大小（rehash）。是有序的或保证顺序的稳定性）。如果在迭代期间对映射进行了修改（结构修改，如添加或删除元素），则迭代可能会抛出。如果你打算在多线程环境中使用它，你需要额外的同步措施，或者可以考虑使用。不保证映射的顺序，特别是它不保证顺序会随着时间的推移而保持不变。操作（假设哈希函数是均匀的，并且表有足够的容量）。值（value）可以是重复的，并且可以为。提供了多种方法来遍历它的键、值或键值对，如。中，键（key）必须是唯一的，并且不能为。
线程池的工作原理
最新发布
qq_42301955的博客
06-05 549
线程池总结
Springboot vue3 elementplus 景点评论数据分析与可视化系统源码
scian22的博客
06-04 444
系统演示:链接：https://pan.baidu.com/s/1J056R4rYji_mc4gwteZEzg?
Javascript-对象
m0_63019813的博客
06-05 302
对象的创建
java如何实现请求
m0_75032658的博客
06-03 150
如果你想要向数据库发送请求（如查询、更新等），你可以使用Java的JDBC（Java Database Connectivity）API。在Java中，实现请求通常指的是通过网络发送HTTP请求到服务器，或者通过其他协议（如JDBC）向数据库发送请求。注意：在使用Apache HttpClient之前，你需要将其添加到你的项目中。是Java标准库中的一个类，它允许你发送HTTP请求并接收响应。以下是一个简单的示例，展示如何使用。请注意，对于数据库连接，你需要添加相应的JDBC驱动依赖到你的项目中。
排序算法之快速排序
my_air的博客
06-04 316
排序算法之快速排序
Spring运维之boot项目打包jar和插件运行并且设置启动时临时属性和自定义配置文件
多多的博客
06-04 1135
配置文件默认都是啊application开头的可以改的写一个简单的boot项目控制层用rest模式开发重命名配置文件但这样就不会提示了运行后后会存在找到其他配置文件的情况 我们要到文件资源管理器里面去查找我们可以在boot项目配置里面去手动设置指定配置文件yml不生效的大概率port:后面没有空格如果配置文件是yml修改填入的参数有所不同加入多个文件参数不同 用逗号隔开当我们配置多个配置文件的时候是后面一个配置文件里面的配置生效小结这都是boot官方文档中标注的知识。
go语言接口之flag.Value接口
wyx的博客
06-05 416
调用Var方法将标记加入应用的命令行标记集合中，有异常复杂命令行接口的全局变量 flag.CommandLine.Programs可能有几个这个类型的变量。调用Var方法将一个celsiusFlag参 数赋值给一个flag.Value参数,导致编译器去检查celsiusFlag是否有必须的方法。flag.Duration 函数创建一个time.Duration类型的标记变量并且允许用户通过多种用户友好的方式来设置这 个变量的大小，这种方式还包括和String方法相同的符号排版形式。
《java数据结构》--哈希表
hyldzbg的博客
06-02 1377
大概方法就是，将表中的每一个位置加上一个状态，状态有三种，空，有值，删除，删除状态就是这个位置之前有值但是现在被删除了，但是这个位置的值并没有改变，而是将状态设定为删除，这样我们进行其他操作就能知道那些时不用选中的了，这样我们即完成了删除又可以找到另一个冲突的值。，当然不是，如果只是简单的将原来的数据拷贝过来，这时数组大小扩容总空间变大，根据我们的哈希函数。如果不扩容的话，表的长度就是一定的，负载因子就和“插入表中的元素个数”成正比，所以，负载因子越大，表明插入表中的元素越多，冲突产生的概率越大；
java 文件多线程
07-27
- *1* *2* *3* [【Java】网络编程——多线程下载文件](https://blog.csdn.net/qq_42470947/article/details/105889839)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值