多线程（一）

最新推荐文章于 2024-07-14 14:59:27 发布
最新推荐文章于 2024-07-14 14:59:27 发布
阅读量115 收藏
点赞数
文章标签： java 操作系统
原文链接：https://juejin.im/post/5ae09d62f265da0b7d0b0f72
版权

一、synchronized关键字

1、锁重入

1.1、调用其他同步方法

同步方法 - 调用其他同步方法 锁可重入。 同一个线程，多次调用同步代码，锁定同一个锁对象，可重入。

/**
 * synchronized关键字
 * 同步方法 - 调用其他同步方法
 * 锁可重入。 同一个线程，多次调用同步代码，锁定同一个锁对象，可重入。
 */
package concurrent.t01;

import java.util.concurrent.TimeUnit;

public class Test_06 {
	
	synchronized void m1(){ // 锁this
		System.out.println("m1 start");
		try {
			TimeUnit.SECONDS.sleep(2);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		m2();
		System.out.println("m1 end");
	}
	synchronized void m2(){ // 锁this
		System.out.println("m2 start");
		try {
			TimeUnit.SECONDS.sleep(1);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		System.out.println("m2 end");
	}
	
	public static void main(String[] args) {
		
		new Test_06().m1();
		
	}
	
}
复制代码

结果：

m1 start
m2 start
m2 end
m1 end
复制代码

1.2、继承

/**
 * synchronized关键字
 * 同步方法 - 继承
 * 子类同步方法覆盖父类同步方法。可以指定调用父类的同步方法。
 * 相当于锁的重入。
 */
package concurrent.t01;

import java.util.concurrent.TimeUnit;

public class Test_07 {
	
	synchronized void m(){
		System.out.println("Super Class m start");
		try {
			TimeUnit.SECONDS.sleep(1);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		System.out.println("Super Class m end");
	}
	
	public static void main(String[] args) {
		new Sub_Test_07().m();
	}
	
}

class Sub_Test_07 extends Test_07{
	synchronized void m(){
		System.out.println("Sub Class m start");
		super.m();
		System.out.println("Sub Class m end");
	}
}
复制代码

结果：

Sub Class m start
Super Class m start
Super Class m end
Sub Class m end
复制代码

2、锁与异常

当同步方法中发生异常的时候，自动释放锁资源。不会影响其他线程的执行。

/**
 * synchronized关键字
 * 同步方法 - 锁与异常
 * 当同步方法中发生异常的时候，自动释放锁资源。不会影响其他线程的执行。
 * 注意，同步业务逻辑中，如果发生异常如何处理。
 */
package concurrent.t01;

import java.util.concurrent.TimeUnit;

public class Test_08 {
	int i = 0;
	synchronized void m(){
		System.out.println(Thread.currentThread().getName() + " - start");
		while(true){
			i++;
			System.out.println(Thread.currentThread().getName() + " - " + i);
			try {
				TimeUnit.SECONDS.sleep(1);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			if(i == 5){
				i = 1/0;
			}
		}
	}
	
	public static void main(String[] args) {
		final Test_08 t = new Test_08();
		new Thread(new Runnable() {
			@Override
			public void run() {
				t.m();
			}
		}, "t1").start();
		
		new Thread(new Runnable() {
			@Override
			public void run() {
				t.m();
			}
		}, "t2").start();
	}
	
}
复制代码

结果：

t1 - start
t1 - 1
t1 - 2
t1 - 3
t1 - 4
t1 - 5
t2 - start
t2 - 6
Exception in thread "t1" java.lang.ArithmeticException: / by zero
	at concurrent.t01.Test_08.m(Test_08.java:25)
	at concurrent.t01.Test_08$1.run(Test_08.java:35)
	at java.lang.Thread.run(Unknown Source)
t2 - 7
t2 - 8
t2 - 9
t2 - 10
t2 - 11
t2 - 12
复制代码

3、锁对象变更问题

/**
 * synchronized关键字
 * 锁对象变更问题
 * 同步代码一旦加锁后，那么会有一个临时的锁引用执行锁对象，和真实的引用无直接关联。
 * 在锁未释放之前，修改锁对象引用，不会影响同步代码的执行。
 */
package concurrent.t01;

import java.util.concurrent.TimeUnit;

public class Test_13 {
	Object o = new Object();

	int i = 0;
	int a(){
		try{
			/*
			 * return i ->
			 * int _returnValue = i; // 0;
			 * return _returnValue;
			 */
			return i;
		}finally{
			i = 10;
		}
	}
	
	void m(){
		System.out.println(Thread.currentThread().getName() + " start");
		synchronized (o) {
			while(true){
				try {
					TimeUnit.SECONDS.sleep(1);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
				System.out.println(Thread.currentThread().getName() + " - " + o);
			}
		}
	}
	
	public static void main(String[] args) {
		final Test_13 t = new Test_13();
		new Thread(new Runnable() {
			@Override
			public void run() {
				t.m();
			}
		}, "thread1").start();
		try {
			TimeUnit.SECONDS.sleep(3);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		Thread thread2 = new Thread(new Runnable() {
			@Override
			public void run() {
				t.m();
			}
		}, "thread2");
		t.o = new Object();
		thread2.start();
		
		System.out.println(t.i);
		System.out.println(t.a());
		System.out.println(t.i);
	}
	
}
复制代码

结果：锁对象和方法中的锁不是同一个

thread1 start
thread1 - java.lang.Object@5897451a
thread1 - java.lang.Object@5897451a
thread1 - java.lang.Object@5650b078
0
0
10
thread2 start
thread2 - java.lang.Object@5650b078
thread1 - java.lang.Object@5650b078
thread2 - java.lang.Object@5650b078
thread1 - java.lang.Object@5650b078
thread2 - java.lang.Object@5650b078
thread1 - java.lang.Object@5650b078
复制代码

3、常量问题

/**
 * synchronized关键字
 * 常量问题
 * 在定义同步代码块时，不要使用常量对象作为锁对象。
 */
package concurrent.t01;

public class Test_14 {
	String s1 = "hello";
	String s2 = new String("hello"); // new关键字，一定是在堆中创建一个新的对象。
	Integer i1 = 1;
	Integer i2 = 1;
	void m1(){
		synchronized (i1) {
			System.out.println("m1()");
			while(true){
				
			}
		}
	}
	
	void m2(){
		synchronized (i2) {
			System.out.println("m2()");
			while(true){
				
			}
		}
	}
	
	public static void main(String[] args) {
		final Test_14 t = new Test_14();
		new Thread(new Runnable() {
			@Override
			public void run() {
				t.m1();
			}
		}).start();
		
		new Thread(new Runnable() {
			@Override
			public void run() {
				t.m2();
			}
		}).start();
	}
	
}
复制代码

结果：m1和m2方法用的同一个常量，另一个线程一直处于等待状态

m1()
复制代码

二、volatile关键字

1、volatile的可见性

/**
 * volatile关键字
 * volatile的可见性
 * 通知OS操作系统底层，在CPU计算过程中，都要检查内存中数据的有效性。保证最新的内存数据被使用。
 * 
 */
package concurrent.t01;

import java.util.concurrent.TimeUnit;

public class Test_09 {
	
	volatile boolean b = true;
	
	void m(){
		System.out.println("start");
		while(b){}
		System.out.println("end");
	}
	
	public static void main(String[] args) {
		final Test_09 t = new Test_09();
		new Thread(new Runnable() {
			@Override
			public void run() {
				t.m();
			}
		}).start();
		
		try {
			TimeUnit.SECONDS.sleep(1);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		
		t.b = false;
	}
	
}
复制代码

结果：方法执行结束

start
end
复制代码

2、volatile的非原子性问题

/**
 * volatile关键字
 * volatile的非原子性问题
 * volatile， 只能保证可见性，不能保证原子性。
 * 不是枷锁问题，只是内存数据可见。
 */
package concurrent.t01;

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

public class Test_10 {
	
	volatile int count = 0;
	/*synchronized*/ void m(){
		for(int i = 0; i < 10000; i++){
			count++;
		}
	}
	
	public static void main(String[] args) {
		final Test_10 t = new Test_10();
		List<Thread> threads = new ArrayList<>();
		for(int i = 0; i < 10; i++){
			threads.add(new Thread(new Runnable() {
				@Override
				public void run() {
					t.m();
				}
			}));
		}
		for(Thread thread : threads){
			thread.start();
		}
		for(Thread thread : threads){
			try {
				thread.join();
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
		System.out.println(t.count);
	}
}
复制代码

结果：没有按照我们想象的100000次，少于100000次

37859
复制代码

三、AtomicXxx

/**
 * AtomicXxx
 * 同步类型
 * 原子操作类型。 其中的每个方法都是原子操作。可以保证线程安全。
 */
package concurrent.t01;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.atomic.AtomicInteger;

public class Test_11 {
	AtomicInteger count = new AtomicInteger(0);
	void m(){
		for(int i = 0; i < 10000; i++){
			/*if(count.get() < 1000)*/
				count.incrementAndGet();
		}
	}
	
	public static void main(String[] args) {
		final Test_11 t = new Test_11();
		List<Thread> threads = new ArrayList<>();
		for(int i = 0; i < 10; i++){
			threads.add(new Thread(new Runnable() {
				@Override
				public void run() {
					t.m();
				}
			}));
		}
		for(Thread thread : threads){
			thread.start();
		}
		for(Thread thread : threads){
			try {
				thread.join();
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
		System.out.println(t.count.intValue());
	}
}
复制代码

结果：

100000
复制代码

四、门闩 - CountDownLatch

/**
 * 门闩 - CountDownLatch
 * 可以和锁混合使用，或替代锁的功能。
 * 在门闩未完全开放之前等待。当门闩完全开放后执行。
 * 避免锁的效率低下问题。
 */
package concurrent.t01;

import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;

public class Test_15 {
	CountDownLatch latch = new CountDownLatch(5);
	
	void m1(){
		try {
			latch.await();// 等待门闩开放。
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		System.out.println("m1() method");
	}
	
	void m2(){
		for(int i = 0; i < 10; i++){
			if(latch.getCount() != 0){
				System.out.println("latch count : " + latch.getCount());
				latch.countDown(); // 减门闩上的锁。
			}
			try {
				TimeUnit.MILLISECONDS.sleep(500);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			System.out.println("m2() method : " + i);
		}
	}
	
	public static void main(String[] args) {
		final Test_15 t = new Test_15();
		new Thread(new Runnable() {
			@Override
			public void run() {
				t.m1();
			}
		}).start();
		
		new Thread(new Runnable() {
			@Override
			public void run() {
				t.m2();
			}
		}).start();
	}
	
}
复制代码

结果：

latch count : 5
m2() method : 0
latch count : 4
m2() method : 1
latch count : 3
m2() method : 2
latch count : 2
m2() method : 3
latch count : 1
m1() method
m2() method : 4
m2() method : 5
m2() method : 6
m2() method : 7
m2() method : 8
m2() method : 9
复制代码

练习：

自定义容器，提供新增元素（add）和获取元素数量（size）方法。
启动两个线程。线程1向容器中新增10个数据。线程2监听容器元素数量，当容器元素数量为5时，线程2输出信息并终止。
复制代码

1)、使用volatile关键字

/**
 * volatile
 */
package concurrent.t02;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.TimeUnit;

public class Test_01 {
	public static void main(String[] args) {
		final Test_01_Container t = new Test_01_Container();
		new Thread(new Runnable() {
			@Override
			public void run() {
				for(int i = 0; i < 10; i++){
					System.out.println("add Object to Container " + i);
					t.add(new Object());
					try {
						TimeUnit.SECONDS.sleep(1);
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
				}
			}
		}).start();
		
		new Thread(new Runnable(){
			@Override
			public void run() {
				while(true){
					if(t.size() == 5){
						System.out.println("size = 5");
						break;
					}
				}
			}
		}).start();
	}
}

class Test_01_Container{
	volatile List<Object> container = new ArrayList<>();
	
	public void add(Object o){
		this.container.add(o);
	}
	
	public int size(){
		return this.container.size();
	}
}
复制代码

结果：

add Object to Container 0
add Object to Container 1
add Object to Container 2
add Object to Container 3
add Object to Container 4
size = 5
add Object to Container 5
add Object to Container 6
add Object to Container 7
add Object to Container 8
add Object to Container 9
复制代码

2)、wait notify

/**
 * wait notify
 */
package concurrent.t02;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.TimeUnit;

public class Test_02 {
	public static void main(String[] args) {
		final Test_02_Container t = new Test_02_Container();
		final Object lock = new Object();
		
		new Thread(new Runnable(){
			@Override
			public void run() {
				synchronized (lock) {
					if(t.size() != 5){
						try {
							lock.wait(); // 线程进入等待队列。
						} catch (InterruptedException e) {
							e.printStackTrace();
						}
					}
					System.out.println("size = 5");
					lock.notifyAll(); // 唤醒其他等待线程
				}
			}
		}).start();
		
		new Thread(new Runnable() {
			@Override
			public void run() {
				synchronized (lock) {
					for(int i = 0; i < 10; i++){
						System.out.println("add Object to Container " + i);
						t.add(new Object());
						if(t.size() == 5){
							lock.notifyAll();
							try {
								lock.wait();
							} catch (InterruptedException e) {
								e.printStackTrace();
							}
						}
						try {
							TimeUnit.SECONDS.sleep(1);
						} catch (InterruptedException e) {
							e.printStackTrace();
						}
					}
				}
			}
		}).start();
	}
}

class Test_02_Container{
	List<Object> container = new ArrayList<>();
	
	public void add(Object o){
		this.container.add(o);
	}
	
	public int size(){
		return this.container.size();
	}
}
复制代码

结果：

add Object to Container 0
add Object to Container 1
add Object to Container 2
add Object to Container 3
add Object to Container 4
size = 5
add Object to Container 5
add Object to Container 6
add Object to Container 7
add Object to Container 8
add Object to Container 9
复制代码

3）、CountDownLatch

/**
 * CountDownLatch 门闩
 */
package concurrent.t02;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.CyclicBarrier;
import java.util.concurrent.Semaphore;
import java.util.concurrent.TimeUnit;

public class Test_03 {
	public static void main(String[] args) {
		final Test_03_Container t = new Test_03_Container();
		final CountDownLatch latch = new CountDownLatch(1);

		new Thread(new Runnable(){
			@Override
			public void run() {
				if(t.size() != 5){
					try {
						latch.await(); // 等待门闩的开放。 不是进入等待队列
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
				}
				System.out.println("size = 5");
			}
		}).start();
		
		new Thread(new Runnable() {
			@Override
			public void run() {
				for(int i = 0; i < 10; i++){
					System.out.println("add Object to Container " + i);
					t.add(new Object());
					if(t.size() == 5){
						latch.countDown(); // 门闩-1
					}
					try {
						TimeUnit.SECONDS.sleep(1);
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
				}
			}
		}).start();
	}
}

class Test_03_Container{
	List<Object> container = new ArrayList<>();
	
	public void add(Object o){
		this.container.add(o);
	}
	
	public int size(){
		return this.container.size();
	}
}
复制代码

结果：

add Object to Container 0
add Object to Container 1
add Object to Container 2
add Object to Container 3
add Object to Container 4
size = 5
add Object to Container 5
add Object to Container 6
add Object to Container 7
add Object to Container 8
add Object to Container 9
复制代码
Rank92
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
一个类，有新增元素（add）和获取元素数量（size）方法。 启动两个线程。线程1向容器中新增数据。线程2监听容器元素数量，当容器元素数量为5时，线程2输出信息并终止...
weixin_30657999的博客
10-21 336
方式一： /** * 两个线程要是可见的所以要加上votalile */public class Test_01 { public static void main(String[] args) { final Test_01_Container t = new Test_01_Container(); new Thread(new Ru...
多线程面试题1
Wdoves的博客
09-19 194
题目：自定义容器，提供新增元素（add）和获取元素数量（size）方法。 启动两个线程。线程1向容器中新增10个数据。线程2监听容器元素数量，当容器元素数量为5时，线程2输出信息并终止。 =============================================================================================== 使用三种方法...
多线程之生产者和消费者模式
qq_44767889的博客
01-13 270
生产者和消费者模式是多线程开发者经常见到的一种模式，生产者用来生产数据，然后将生成的数据放到中间容器，而消费者这是从中间容器中取出数据进行消费处理。消费者和生产者模式可以让代码达到高内聚低耦合的目的。 import threading import random gMoney=0 gLock=threading.Lock() class Producer(threading.Thread):...
04 面试题系列 | 编程题：实现一个容器，提供两个方法，add,size。写两个线程，线程 1 添加 10 个元素到容器中，线程 2 实现监控元素的个数，当个数到 5 个时，线程 2 给出提示并结束
程序猿杂货铺
03-18 588
题目 实现一个容器，提供两个方法，add,size。写两个线程，线程 1 添加 10 个元素到容器中，线程 2 实现监控元素的个数，当个数到 5 个时，线程 2 给出提示并结束。 用普通线程方法来实现 用 volitile 关键字实现 用 wait 和 notify 实现 使用 latch 替代 wait notify 实现 用普通线程方法来实现 public class MyContaine...
labview多线程学习
09-03
在LabVIEW中，多线程技术是一种优化程序性能的重要手段，特别是在处理大量数据、进行实时测量或控制多个硬件设备时，多线程能显著提高程序的执行效率。 多线程学习在LabVIEW中的核心概念： 1. **线程与并行执行**...
多线程支持库
07-24
在计算机科学领域，多线程是一种程序设计技术，它允许应用程序同时执行多个任务或子任务。多线程支持库就是为了让开发者更容易地在程序中利用多线程特性而设计的一系列工具和接口。这些库提供了丰富的功能，如线程...
Python多线程详解
01-27
线程有5种状态，状态转换的过程如下图所示：多线程的优势在于可以同时运行多个任务（至少感觉起来是这样）。但是当线程需要共享数据时，可能存在数据不同步的问题。考虑这样一种情况：一个列表里所有元素都是0，线程...
qt websocket 客户端 多线程使用
09-16
qt 使用QWebSocket 创建websocket客户端来读取数据，异步链接，并且放入到线程中去执行，线程池的基础，代码使用两个用户，放入到一个线程中执行，同理，可以多个用户放入到多个线程中执行，为线程池执行websocket ...
大漠多线程模板_大漠_大漠多线程_
09-30
在IT行业中，多线程是程序设计中的一个重要概念，特别是在C#编程中。"大漠多线程模板"是一个专门针对C#开发的多线程处理框架，它为开发者提供了便捷的方式来管理和优化多线程应用。这个框架由知名开发者"大漠"创建，...
java多线程之Thread类
weixin_34273481的博客
06-13 112
Class Thread java.lang.Object java.lang.Thread 实现接口：Runnable直接被继承的子类：ForkJoinWorkerThread public class Thread extends Object implements Runnable thread是程序中的执行线程，Jav...
配置Java开发环境
Broken_x的博客
07-10 1516
Java开发环境配置
java版的上门家政系统和PHP版的上门家政有什么区别？
baina666的博客
07-12 492
综上所述，Java版和PHP版的上门家政系统各有优缺点，选择哪种语言主要取决于项目的具体需求、预算、开发团队的技术栈以及未来的扩展计划等因素。同时，由于Java生态系统的复杂性和多样性，也可能需要投入更多的时间和资源来学习和掌握相关的技术和工具。Java版：Java拥有庞大的生态系统和丰富的第三方库，这为家政系统的开发和扩展提供了强大的支持。Java版：由于Java的编译执行机制和高效的垃圾回收算法，Java版家政系统通常具有更高的运行效率和更好的性能表现，尤其是在处理高并发、大数据量等复杂场景时。
Spring Security 授权
最新发布
persistence_PSH的博客
07-14 672
在 loadUserByUsername 方法，在查询数据库用户信息的时候，同时查询出用户的权限，这里以角色名代指权限。在 loadUserByUsername 方法，在查询数据库用户信息的时候，同时查询出用户的权限，这里以角色名代指权限。在 loadUserByUsername 方法，在查询数据库用户信息的时候，同时查询出用户的权限，这里以角色名代指权限。通过 RBAC 获取到用户的具体权限后，再通过 Security 的 用户-权限-资源 来进行权限控制。HttpSecurity 权限配置。
【Go系列】 Sync并发控制
u013379032的博客
07-14 604
在上一篇文章中，我们介绍了goroutine和channel，理论上，通过channel可以实现并发控制，但是其他语言的开发者可能更习惯一些原子操作的库。当然Go语言也会提供这样的库，所以我们今天了解一下sync库。
elk部署springboot
Chihirozy的博客
07-11 330
elk部署springboot。
Java方法练习-双色球彩票系统
T1798218285的博客
07-11 274
红色球号码从1-33中选择；蓝色球号码从1-16中选择。投注号码由6个红色球号码和1个蓝色球号码组成。三等奖 5+1 / 5+0 3000。四等奖4+1 / 4+0 200。六等奖1+1 / 1+0 5。一等奖6+1 1000w。二等奖6+0 500w。五等奖3+1 / 2+1。
多线程一个数据源还是多个数据源高效
04-12
在进行多线程处理的时候，如果多个线程都需要访问同一个数据源，可能会导致线程之间的竞争，造成效率低下、资源浪费等问题。因此，在处理多线程的时候，如果数据源可以被拆分成多个独立的部分，则可以将每个线程分配...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值