java-多线程2（同步框架）

最新推荐文章于 2024-05-11 13:15:50 发布
最新推荐文章于 2024-05-11 13:15:50 发布
阅读量582 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/konglinglf/article/details/17202493
版权


1.传统定时器的使用

       时器类Timer在java.util包中。使用时，先实例化，然后使用实例的schedule()方法，设定指定的任务task在指定的延迟delay后执行。定时器任务类TimerTask是抽象类，继承并重写其run()方法，可实现具体任务。

       new Timer().schedule(
       new TimerTask()

       {
              public void run()

        {
        System.out.println(Thread.currentThread().getName());
       }
}, 10000,1000);


2.线程池的使用:

       Executors类里面提供了一些静态工厂，生成一些常用的线程池。

       newSingleThreadExecutor：创建一个单线程的线程池。这个线程池只有一个线程在工作，也就是相当于单线程串行执行所有任务。如果这个唯一的线程因为异常结束，那么会有一个新的线程来替代它。此线程池保证所有任务的执行顺序按照任务的提交顺序执行。

       newFixedThreadPool：创建固定大小的线程池。每次提交一个任务就创建一个线程，直到线程达到线程池的最大大小。线程池的大小一旦达到最大值就会保持不变，如果某个线程因为执行异常而结束，那么线程池会补充一个新线程。

       newCachedThreadPool：创建一个可缓存的线程池。如果线程池的大小超过了处理任务所需要的线程，那么就会回收部分空闲（60秒不执行任务）的线程，当任务数增加时，此线程池又可以智能的添加新线程来处理任务。此线程池不会对线程池大小做限制，线程池大小完全依赖于操作系统（或者说JVM）能够创建的最大线程大小。

       newScheduledThreadPool：创建一个大小无限的线程池。此线程池支持定时以及周期性执行任务的需求。

       newSingleThreadExecutor：创建一个单线程的线程池。此线程池支持定时以及周期性执行任务的需求。

程序示例：

ScheduledExecutorService service =  Executors.newScheduledThreadPool(3);
		service.scheduleAtFixedRate(
				new Runnable(){
					public void run() {
						System.out.println(Thread.currentThread().getName());
					}
					
				},
				10,
				1,
				TimeUnit.SECONDS);
		
		while(true){
			try {
				Thread.sleep(2000);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			System.out.println(Thread.currentThread().getName());
		}


线程锁技术

       在Java5中，专门提供了锁对象，利用锁可以方便的实现资源的封锁，用来控制对竞争资源并发访问的控制，这些内容主要集中在java.util.concurrent.locks 包下面，里面有三个重要的接口Condition、Lock、ReadWriteLock

使用示例：

class Business{
	private int count = 0;
	Lock lock = new ReentrantLock();
	public void service(){
		lock.lock();
		count++;
		try {
			Thread.sleep(10);
			System.out.println(count);		
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}finally{
			lock.unlock();
		}


	}


Callable与 Future 

       两功能是Java在后续版本中为了适应多并法才加入的，Callable是类似于Runnable的接口，实现Callable接口的类和实现Runnable的类都是可被其他线程执行的任务。

public class FutureTest {
	public static void main(String[] args) {
		ExecutorService service = Executors.newSingleThreadExecutor();
		class MyCallable implements Callable<String>{
			public String call() throws Exception {
				for(int i=0;i<10;i++)
				{
					Thread.sleep(1000);
					System.out.println("calling " + i);					
				}
				return "hello";
			}		
		}
		//Future<String> future = service.submit(new MyCallable());
		class MyCallable2<T> implements Callable<T>{
			public T call() throws Exception {
				for(int i=0;i<10;i++)
				{
					Thread.sleep(1000);
					System.out.println("calling " + i);					
				}
				return null;
			}	
		}				
		Future<String> future = service.submit(new Callable<String>(){
			public String call() throws Exception {
				for(int i=0;i<10;i++)
				{
					Thread.sleep(1000);
					System.out.println("calling " + i);					
				}
				return "hello";
			}		
		});		
		try {
			//加上下面这句则暂停失败，还能看到上面打印的calling。
			//Thread.sleep(2000);			
			//future.cancel(false);
			//System.out.println(future.isCancelled());
			if(true)
				System.out.println(future.get());
		} catch (Exception e) {
			e.printStackTrace();
		}
		System.out.println("end!");
		service.shutdown();
		CompletionService<String> ecs = new ExecutorCompletionService<String>(
				Executors.newSingleThreadExecutor()				
		);
		for(int i=0;i<10;i++) {
			ecs.submit(new MyCallable());
		}
		try {
			for(int i=0;i<10;i++){
				Future<String> future2 = ecs.take();
				System.out.println(future2.get());
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
}
java信号量Semaphore

       Semaphore当前在多线程环境下被扩放使用，操作系统的信号量是个很重要的概念，在进程控制方面都有应用。Java 并发库 的Semaphore 可以很轻松完成信号量控制，Semaphore可以控制某个资源可被同时访问的个数，通过 acquire() 获取一个许可，如果没有就等待，而 release() 释放一个许可。比如在Windows下可以设置共享文件的最大客户端访问个数。

程序示例：

public class SemaphoreTest {
	public static void main(String[] args) {
		ExecutorService service = Executors.newCachedThreadPool();
		final  Semaphore sp = new Semaphore(3);
		for(int i=0;i<10;i++){
			Runnable runnable = new Runnable(){
					public void run(){
					try {
						sp.acquire();
					} catch (InterruptedException e1) {
						e1.printStackTrace();
					}
					System.out.println("线程" + Thread.currentThread().getName() + 
							"进入，当前已有" + (3-sp.availablePermits()) + "个并发");
					try {
						Thread.sleep((long)(Math.random()*10000));
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
					System.out.println("线程" + Thread.currentThread().getName() + 
							"即将离开");					
					sp.release();
					//下面代码有时候执行不准确，因为其没有和上面的代码合成原子单元
					System.out.println("线程" + Thread.currentThread().getName() + 
							"已离开，当前已有" + (3-sp.availablePermits()) + "个并发");					
				}
			};
			service.execute(runnable);			
		}
	}

}

CyclicBarrier

       在实际应用中，有时候需要多个线程同时工作以完成同一件事情，而且在完成过程中，往往会等待其他线程都完成某一阶段后再执行，等所有线程都到达某一个阶段后再统一执行。 其中，的barrier就是相当于一个阻断，障碍器，CyclicBarrier最重要的属性就是参与者个数，另外最要方法是await()。当所有线程都调用了await()后，就表示这些线程都可以继续执行，否则就会等待。 

public class CyclicBarrierTest {

	public static void main(String[] args) {
		ExecutorService service = Executors.newCachedThreadPool();
		final  CyclicBarrier cb = new CyclicBarrier(3);
		for(int i=0;i<3;i++){
			Runnable runnable = new Runnable(){
					public void run(){
					try {
						Thread.sleep((long)(Math.random()*10000));	
						System.out.println("线程" + Thread.currentThread().getName() + 
								"即将到达集合地点1，当前已有" + cb.getNumberWaiting() + "个已经到达，正在等候");						
						cb.await();
						
						Thread.sleep((long)(Math.random()*10000));	
						System.out.println("线程" + Thread.currentThread().getName() + 
								"即将到达集合地点2，当前已有" + cb.getNumberWaiting() + "个已经到达，正在等候");						
						cb.await();	
						Thread.sleep((long)(Math.random()*10000));	
						System.out.println("线程" + Thread.currentThread().getName() + 
								"即将到达集合地点3，当前已有" + cb.getNumberWaiting() + "个已经到达，正在等候");						
						cb.await();						
					} catch (Exception e) {
						e.printStackTrace();
					}				
				}
			};
			service.execute(runnable);
			
		}
		service.shutdown();
	}
	
}

CountDownLatch

       类在java.util.concurrent包下，一个同步辅助类，在完成一组正在其他线程中执行的操作之前，它允许一个或多个线程一直等待。犹如倒计时计数器，调用CountDownLatch对象的countDown方法就将计数器减1，当计数到达0时，则所有等待者或单个等待者开始执行。

public class CountdownLatchTest {

	public static void main(String[] args) {
		ExecutorService service = Executors.newCachedThreadPool();
		final CountDownLatch cdOrder = new CountDownLatch(1);
		final CountDownLatch cdAnswer = new CountDownLatch(3);		
		for(int i=0;i<3;i++){
			Runnable runnable = new Runnable(){
					public void run(){
					try {
						System.out.println("线程" + Thread.currentThread().getName() + 
								"正准备接受命令");						
						cdOrder.await();
						System.out.println("线程" + Thread.currentThread().getName() + 
						"已接受命令");								
						Thread.sleep((long)(Math.random()*10000));	
						System.out.println("线程" + Thread.currentThread().getName() + 
								"回应命令处理结果");						
						cdAnswer.countDown();						
					} catch (Exception e) {
						e.printStackTrace();
					}				
				}
			};
			service.execute(runnable);
		}		
		try {
			Thread.sleep((long)(Math.random()*10000));
		
			System.out.println("线程" + Thread.currentThread().getName() + 
					"即将发布命令");						
			cdOrder.countDown();
			System.out.println("线程" + Thread.currentThread().getName() + 
			"已发送命令，正在等待结果");	
			cdAnswer.await();
			System.out.println("线程" + Thread.currentThread().getName() + 
			"已收到所有响应结果");	
		} catch (Exception e) {
			e.printStackTrace();
		}				
		service.shutdown();

	}
}
Exchanger
       类java.util.concurrent.Exchanger提供了一个同步点，在这个同步点，一对线程可以交换数据。每个线程通过exchange()方法的入口提供数据给他的伙伴线程，并接收他的伙伴线程提供的数据，并返回。
 

public class ExchangerTest {

	public static void main(String[] args) {
		ExecutorService service = Executors.newCachedThreadPool();
		final Exchanger exchanger = new Exchanger();
		service.execute(new Runnable(){
			public void run() {
				try {				
					Thread.sleep((long)(Math.random()*10000));
					String data1 = "zxx";
					System.out.println("线程" + Thread.currentThread().getName() + 
					"正在把数据" + data1 +"换出去");
					String data2 = (String)exchanger.exchange(data1);
					System.out.println("线程" + Thread.currentThread().getName() + 
					"换回的数据为" + data2);
				}catch(Exception e){
					
				}
			}	
		});
		service.execute(new Runnable(){
			public void run() {
				try {				
					Thread.sleep((long)(Math.random()*10000));
					String data1 = "lhm";
					System.out.println("线程" + Thread.currentThread().getName() + 
					"正在把数据" + data1 +"换出去");
					String data2 = (String)exchanger.exchange(data1);
					System.out.println("线程" + Thread.currentThread().getName() + 
					"换回的数据为" + data2);
				}catch(Exception e){
					
				}				
			}	
		});		
	}

}




liufeics
关注
java线程同步inc dec_Java多线程进阶（十一）—— J.U.C之locks框架：StampedLock
weixin_39805539的博客
02-13 233
一、StampedLock类简介StampedLock类，在JDK1.8时引入，是对读写锁ReentrantReadWriteLock的增强，该类提供了一些功能，优化了读锁、写锁的访问，同时使读写锁之间可以互相转换，更细粒度控制并发。首先明确下，该类的设计初衷是作为一个内部工具类，用于辅助开发其它线程安全组件，用得好，该类可以提升系统性能，用不好，容易产生死锁和其它莫名其妙的问题。1.1 Stam...
java集合框架线程同步代码详解
08-28
主要介绍了java集合框架线程同步代码详解，具有一定借鉴价值，需要的朋友可以参考下。
Java线程同步的解决方案——synchronized与Lock
Hopefully Sky的博客
03-19 5067
要说明线程同步问题首先要说明Java线程的两个特性，可见性和有序性。多个线程之间是不能直接传递数据交互的，它们之间的交互只能通过共享变量来实现。例如，假设在多个线程之间共享了Count类的一个对象，Count类有一个私有域num和一个公有方法count(),count()方法对num进行加1操作。这个对象是被创建在主内存(堆内存)中，每个线程都有自己的工作内存(线程栈)，工作内存存储了主内存Cou
java.util.concurrent 同步器框架详解
weixin_30268071的博客
07-05 175
作者简介 善光，一个半年才打一次篮球的程序猿。一直从事 Java 化开发，目前负责物流压力平衡、千里眼和风暴眼 Java 化项目。 引言 一般的应用系统中，存在着大量的计算和大量的 I/O 处理，通过多线程可以让系统运行得更快。但在 Java 多线程编程中，会面临很多的难题，比如线程安全、上下文切换、死锁等问题。 线程安全 引用 《Java Concurrency in Practice》 的...
Java高级编程——多线程（生命周期+线程同步）
ou_yang_mu_ling的博客
08-29 347
3、线程的生命周期 4、线程的同步（重点） 5、线程的通信 6、新增线程创建方式
16.0、Java多线程——线程同步机制
m0_52433668的博客
07-20 216
什么是并发？ 并发就是同一个对象被多个线程同时操作 举个例子： 10000 人同时抢 1张票，或者两个人同时取一张卡里的钱 什么是线程同步？ 现实生活中，我们会遇到 “ 同一个资源很多人都想使用 ” 的问题，比如，食堂排队打饭，每个人都想吃饭，最天然的解决办法就是 -> 排队，一个个来。 那么排队在程序中就叫做 队列 处理多线程问题时，多个线程访问同一个对象，并且某些线程还想修改这个对象，那么这时候我们就需要线程.........
JAVA-多线程 所有文件
01-09
这个“JAVA-多线程 所有文件”压缩包很可能包含了一系列关于Java多线程学习的源代码示例和相关文档。下面我们将深入探讨Java多线程的相关知识点。 1. **线程的概念**：线程是操作系统分配CPU时间的基本单位，一个...
Java-Java线程编程教程
11-14
本教程将深入探讨Java多线程的相关概念、原理及实战技巧。 首先，我们需要理解什么是线程。线程是程序执行的基本单元，一个进程中可以包含多个线程，每个线程都拥有独立的程序计数器、系统栈以及局部变量。多线程...
Java-REST-SOAP-AeroSpike-多线程
02-11
总之，这个主题覆盖了Java多线程编程、REST和SOAP服务的创建、以及AeroSpike数据库的使用，这些都是现代软件开发中的重要技术。理解和掌握这些知识点，对于提升Java开发者在企业级应用开发中的技能和竞争力至关重要...
人工智能-项目实践-多线程-Java多线程高并发实例.zip
01-04
总之，这个项目实例旨在帮助开发者掌握Java多线程技术，提升处理高并发场景的能力，这对于在人工智能领域进行大数据处理和实时计算的项目尤其重要。通过对这些实例的学习和实践，你将能够更好地驾驭Java并发编程，为...
理解高并发_我对并发编程的理解
07-20 686
对于并发编程， 涉及的技术点非常多， 我们首先需要明确一些基本概念，只有概念清晰，才能做到在以后深入学习关键技术的过程中不致于感觉到吃力和迷惑。 其次，我们还需要明白在并发编程最需要关注的问题是什么？ 带着关键问题去学习，才能够起到事办功倍、稳扎稳打的效果。 下面是我所总结的一些很多人容易混淆的概念： 1. 高并发、多线程 ● 高并发 ...
多线程编程（二）：同步器框架——AQS
小不妞
09-17 542
一. AQS背景了解 参考：https://www.cnblogs.com/shoshana-kong/p/10835181.html java.util.concurrent并发包中提供了很多同步工具类来帮我们实现同步，整个JUC包的框架图如下：可见AbstractQueuedSynchronizer类是整个JUC包的核心： 二.AQS涉及技术 模板方法：模板方法模式在一个方法...
java synchronizer_Java同步框架AbstractQueuedSynchronizer详解
weixin_39564527的博客
02-16 182
AbstractQueuedSynchronizer概述AbstractQueuedSynchronizer是java中非常重要的一个框架类，它实现了最核心的多线程同步的语义，我们只要继承AbstractQueuedSynchronizer就可以非常方便的实现我们自己的线程同步器，java中的锁Lock就是基于AbstractQueuedSynchronizer来实现的。下面首先展示了Abstra...
JUC线程框架深度解析 — 02、线程同步锁
androidsj的专栏
05-08 2377
     juc的开发架构解决的核心问题是并发访问与数据安全操作问题，当进行并发访问的时候如果对于锁的控制不当，就会造成死锁这样的阻塞问题，那么为了解决这样的缺陷，juc里面重新针对锁的概念进行了设计。【 JUC锁机制 】➣ JUC锁机制包括有如下组成部分：   ➣ 核心接口：Lock、ReadWriteLock；   ➣ AQS抽象类：• AbstractOwnableSynchronizer(...
Java并发框架——同步状态的管理
seaboat——a free boat on the sea.（公众号：远洋号）
01-03 3137
整个AQS框架核心功能都是围绕着其32位整型属性state进行，一般可以说它表示锁的数量，对同步状态的控制可以实现不同的同步工具，例如闭锁、信号量、栅栏等等。为了保证可见性此变量被声明为volatile，保证每次的原子更新都将及时反映到每条线程上。而对于同步状态的管理可以大体分为两块，一是独占模式的管理，另外是共享模式的管理。通过对这两种模式的灵活变换可以实现多种不同的同步器，如下图，对state
Java游戏服务器逻辑单线程,java – 在服务器和客户端上同步游戏逻辑
weixin_35910073的博客
03-13 239
我正在用Java创建一个简单的网络游戏,玩家可以使用键盘键移动块.游戏将在本地服务器上运行,并具有基本规则：每个块将以1 FPS速率自动移动,但**用户可以发送多个移动命令**在这1秒间隔内,从而更新块位置.代码几乎完成,但是在服务器和客户端之间同步时遇到了麻烦.以下是我需要更好理解的一些代码/描述：基础课程class Server{ServerSocket server = new Server...
两种游戏同步方式：帧同步、状态同步
qwery75的博客
12-18 744
状态同步跟帧同步的一个区别就是，状态同步是在服务器计算好状态，再下发给各个客户端，而帧同步是客户端收到操作指令后自己计算状态，然后表现动作。那两种模式下对比可以看出，状态同步具有复杂逻辑一致性，也就是说因为各个客户端拿到的都是一样的状态数据，所以他们的客户端表现都是一致的。因为这个状态的计算是放在了服务器，所以状态同步模式下，服务器的性能消耗是比帧同步要大的。
网络游戏同步技术二：状态同步的优化与实现
最新发布
antsmall的专栏
05-11 1374
本文讲一讲 “状态同步” 的优化手段。
java实现同步的7种方法
qq_36344711的博客
11-07 785
1、使用特殊域变量(volatile)实现线程同步 轻量级，建议能不使用就不使用。 2、同步方法 即有synchronized关键字修饰的方法。 由于java的每个对象都有一个内置锁，当用此关键字修饰方法时， 内置锁会保护整个方法。在调用该方法前，需要获得内置锁，否则就处于阻塞状态。 代码如： public synchronized void save(){} 注： synchroni...
Java多线程编程详解：并发与同步
"JAVA多线程编程详解" 在Java编程中，多线程是一种核心技能，它允许多个任务在同一时间看似并行地运行，提高了应用程序的效率和响应性。线程是程序执行的最小单元，它们是轻量级的，因为它们共享同一个进程的资源，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值