黑马程序员_多线程(4) 并发库应用

最新推荐文章于 2022-02-15 14:34:23 发布
最新推荐文章于 2022-02-15 14:34:23 发布
阅读量566 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/johese/article/details/8674558
版权

                          ------- android培训、java培训、期待与您交流！ ----------

一.线程池

 固定线程池，动态线程池，单例线程池

 定时器线程池

eg:

package com.it;

import java.util.concurrent.Executor;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;

public class ThreadPool {

	/*
	int a,b;
	protected ThreadPool(int a,int b){
		this.a = a;
		this.b = b;
	}
	protected ThreadPool(){
		this(super.a,super.b);
	}
	*/
	
	public static void main(String[] args) {
		// ExecutorService executors = Executors.newFixedThreadPool(3);
		//ExecutorService executors = Executors.newCachedThreadPool();
		 ExecutorService executors = Executors.newSingleThreadExecutor();
		for(int j=0;j<5;j++){
	    final int task = j;
	    synchronized(ThreadPool.class){		
		executors.execute(new Runnable(){

			@Override
			public void run() {
				synchronized(ThreadPool.class){
				for(int i=0;i<10;i++){
					System.out.println(Thread.currentThread().getState()+" ::: "+Thread.currentThread().getName()+" is looping of "+ i+" the task of "+task);
				}
				}	
			 }			
	    	});
	      }
	  }
	  System.out.println(executors.toString());
	  
	 // executors.shutdown();
	  executors.execute(new Runnable(){
           @Override 
           public void run(){
        	   System.out.println(Thread.currentThread().getName()+" the state of threadpool is shut down");
           }
	  });
	
	  System.out.println(executors.toString());
	  
	  Executors.newScheduledThreadPool(3).scheduleAtFixedRate(new Runnable(){
		  
		  @Override
		  public void run(){
			  System.out.println("bomping");
		  }
		  
	  }, 10,2,TimeUnit.SECONDS);
	}
}

-------------------------------------------------------------------------------------------------------------------------------

callable 与 Future

eg：

package com.it;

import java.util.List;
import java.util.Random;
import java.util.concurrent.Callable;
import java.util.concurrent.CompletionService;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorCompletionService;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.ScheduledFuture;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.TimeUnit;

public class CallableAndFuture {

	//private static String result;
	
	private final ScheduledExecutorService schedule = Executors.newScheduledThreadPool(1);
	
	public void beepAnHour(){
		final Runnable beeper = new Runnable(){

			@Override
			public void run() {
				System.out.println(Thread.currentThread().getName()+"--beep--");
				
			}
			
		};
		final ScheduledFuture<?> schedulefuture = schedule.scheduleAtFixedRate(beeper, 10, 10, TimeUnit.SECONDS);
		schedule.schedule(new Runnable(){

			@Override
			public void run() {
				schedulefuture.cancel(true);
			}
			
		}, 60*60, TimeUnit.SECONDS);
	}
	
	public static void mains(String[] args){
		new CallableAndFuture().beepAnHour();
	}
	public static void main(String[] args) {
		/*
	 ExecutorService threadPool = Executors.newFixedThreadPool(10);
	 
	 ExecutorService taskThreadPool = Executors.newSingleThreadExecutor(new ThreadFactory() {
		
		@Override
		public Thread newThread(Runnable r) {
			r = new Runnable(){

				@Override
				public void run() {
					System.out.println("taskThreadPool "+Thread.currentThread().getName());					
				}
				
			};
			return new Thread(r);
		}
	});
	 
	ScheduledExecutorService schedleThreadPool = Executors.newScheduledThreadPool(10);
	schedleThreadPool.schedule(new Callable<String>() {

		@Override
		public String call() throws Exception {
			// TODO 自动生成的方法存根
			return "hello";
		}
		
	}, 10,TimeUnit.SECONDS);
	 //taskThreadPool.
	 
	 for(int i=0;i<20;i++){
	 final int task = i;
	 threadPool.execute(new Runnable(){

		@Override
		public void run() {
			System.out.println(Thread.currentThread().getName()+" the task of "+task);
			
		}
		 
	  });
	 }
	 
	        /*
			try {
		  result = threadPool.submit(new Callable<String>() {

					@Override
					public String call() throws Exception {
					    Thread.sleep(2000);
						return "hello";
					}
					 
				}).get();
			} catch (InterruptedException e) {
				// TODO 自动生成的 catch 块
				e.printStackTrace();
			} catch (ExecutionException e) {
				// TODO 自动生成的 catch 块
				e.printStackTrace();
			}
			
	 */
		/*
	 Future<String> future = threadPool.submit(new Runnable(){

		@Override
		public void run() {
			for(int i=1;i<10;i++){
				System.out.println(Thread.currentThread().getName()+" the looping of "+i);
			}
		}		 
	 },"hello");
	 
		 
	 System.out.println("等待结果");
	 try {
		System.out.println("返回结果:"+future.get());
	} catch (InterruptedException e) {
		// TODO 自动生成的 catch 块
		e.printStackTrace();
	} catch (ExecutionException e) {
		// TODO 自动生成的 catch 块
		e.printStackTrace();
	}
	
	 for(int i=0;i<2;i++){
	 final int task = i;
	 threadPool.execute(new Runnable(){

		@Override
		public void run() {
			for(int i=0;i<10;i++){
				System.out.println(Thread.currentThread().getName()+" the looping of "+i+" the task of "+task);
			}
			
		}	 
	  });
	 }
	 List<Runnable> list = threadPool.shutdownNow();
	 System.out.println(list.toString());
	 for(Runnable runnable : list)
	 runnable.run();
	 */
	 ExecutorService threadPoolDemo = Executors.newFixedThreadPool(10);
	 CompletionService<Integer> completionService = new ExecutorCompletionService<Integer>(threadPoolDemo);
	 for(int i=1;i<=10;i++){
	 final int sequce = i;
	 completionService.submit(new Callable<Integer>() {

		@Override
		public Integer call() throws Exception {
			Thread.sleep(new Random().nextInt(5000));
			return sequce;
		}
	  });
	 }
	 for(int i=1;i<=10;i++){
		try {
			System.out.println(completionService.take().get());
		} catch (InterruptedException e) {
			// TODO 自动生成的 catch 块
			e.printStackTrace();
		} catch (ExecutionException e) {
			// TODO 自动生成的 catch 块
			e.printStackTrace();
		}
	 }
	}
}
---------------------------------------------------------------------------------------------------------------------------------

线程读写锁

eg:

package com.it;

import java.util.Random;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

public class ReadWriteLockDemo {

	class QueueInsrc{
		private Object data;
		private ReentrantReadWriteLock readWriteLock = new ReentrantReadWriteLock();
		protected QueueInsrc(Object data){
			this.data = data;
		}
		public void get(){
			readWriteLock.readLock().lock();
			try{
				System.out.println(Thread.currentThread().getName()+" be ready to read data");
				Thread.sleep((long)Math.random()*1000);
				System.out.println("have readed to data "+this.data);
				}catch(InterruptedException e){
					System.err.println(e.toString());
				}
			finally{
				readWriteLock.readLock().unlock();
			}
		}
		public void put(Object data){
			readWriteLock.writeLock().lock();
			try{
				System.out.println(Thread.currentThread().getName()+" be ready to write data");
				Thread.sleep((long)Math.random()*1000);
				this.data = data;
				System.out.println("have writed to data "+this.data);
			}catch(InterruptedException e){
				System.err.println(e.toString());
			}
			finally{
				readWriteLock.writeLock().unlock();
			}
		}
	}
	public static void main(String[] args) {
        final ReadWriteLockDemo.QueueInsrc queue=new ReadWriteLockDemo().new QueueInsrc(10);
        for(int i=0;i<10;i++){
        new Thread("getThread"){
        	
        	@Override
        	public void run(){
               queue.get();   		
        	}
        }.start();
        
        new Thread(new Runnable(){
			@Override
			public void run() {
			  queue.put(new Random().nextInt(100));				
			}        	
        },"putThread").start();
	 }
	}
}

缓存代理

eg：

package com.it;

	import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Random;
import java.util.Set;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.locks.ReentrantReadWriteLock;
	
	public class CacheItem {
	
		private static Map<String ,Object> cache = new HashMap<String ,Object>();
		private static ReentrantReadWriteLock readWriteLock = new ReentrantReadWriteLock();
		//class 
		public static Object getObject(String key,Object target){
			readWriteLock.readLock().lock();
			Object polixy = null;	
			try{
				polixy = cache.get(key);
				if(polixy==null){
					readWriteLock.readLock().unlock();	
					readWriteLock.writeLock().lock();
					try{
					if(polixy==null){
					  polixy = target;
					  cache.put(key, polixy);
					}	
				 }
				  finally{
					readWriteLock.writeLock().unlock();
				  }
			   }
				readWriteLock.readLock().lock();		
			}
			finally{
				readWriteLock.readLock().unlock();
			}	
		 return polixy;			
	  }
		
		public static void main(String[] args) {
		 final CountDownLatch latch = new CountDownLatch(10);
		  for(int i=0;i<10;i++){
			 final int count = i; 
			 new Thread(new Runnable(){
	
				@Override
				public void run() {
					 try {
						Thread.sleep(3000);
					} catch (InterruptedException e) {
						// TODO 自动生成的 catch 块
						e.printStackTrace();
					}
					 System.out.println(Thread.currentThread().getName()+" ::: "+count+" ::: "+CacheItem.getObject(String.valueOf(count), new Random().nextInt(1000)));
					 latch.countDown();
				}
				 
			 }).start();  
			
		  }
		  try {
				latch.await();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		
		     
			 for(Map.Entry<String, Object>  itdemo : cache.entrySet()){
				 try {
					Thread.sleep(2000);
				} catch (InterruptedException e) {
					// TODO 自动生成的 catch 块
					e.printStackTrace();
				}
				 System.out.println("key="+itdemo.getKey()+","+"value="+itdemo.getValue());
			 }
			 
		//	 System.out.println(cache.toString());
		
		 /*
		 
		   // 键值对集合视图  Key - Value  entrySet() 
	     Set<Map.Entry<String,Object>> set = cache.entrySet();
		 for(Iterator<Map.Entry<String,Object>> it = set.iterator();it.hasNext();){
			 System.out.println(it.next().getKey()+":::"+it.next().getValue());
		 }
		
		 // 键集合视图 key  返回也是Set  keySet()
		 Set<String> key = cache.keySet();
		 for(String k : key){
			 System.out.println(k+":::"+cache.get(k));
		 }
		 
		for(Iterator<String> ey = key.iterator();ey.hasNext();){
			String temp=ey.next();
			System.out.println(temp+" ::: "+cache.get(temp));
		}
		
		//值集合视图   
		Collection coll = cache.values();
		for(Object obj : coll){
			System.out.println(obj);
		}
		
		for(Iterator<Object> value = coll.iterator();value.hasNext();){
			System.out.println(value.next());
		}
		*/
	}	
}

------------------------------------------------------------------------------------------------------------------------------------

Condtion 实现

多个Condition 条件阻塞 ，相当于传统线程notify，wait 通信

阻塞队列的实例

eg:

package com.it;

import java.util.Random;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class ConditionDemo {
	private final Lock lock = new ReentrantLock(); 
	private final Condition isFull = lock.newCondition();
	private final Condition isEmtry = lock.newCondition();
	private String[] data = new String[10];
	private int len, getStr,putStr;
	private StringBuilder buff = new StringBuilder();
	public void putData(){
		lock.lock();
		System.out.println("正在填充数据...");
		try{
			while(putStr<=data.length){
				if(putStr==data.length){
					putStr = 0;
					break;
				}
			data[putStr] = String.valueOf(new Random().nextInt(100));
			System.out.println("data["+putStr+"]="+data[putStr]);
			++putStr;
			++len;
			}
	    if(len!=data.length){
	    	this.putData();
	    }
	    else{	
	    	System.out.println(Thread.currentThread().getName()+" 填充完毕...");
			putStr=buff.length();
			try{
				isFull.await();
			}catch(InterruptedException e){
				System.err.println(e.toString());
			}			 
		  }
	    isEmtry.signal();
	    }
	   finally{
			lock.unlock();
		}	
	}
	public void getData(){
		lock.lock();
		System.out.println("正在截获信息...");
		try{			
		 while(getStr<=data.length){
		 if(getStr==data.length){
			 getStr = 0;
			 break;
		 }
		 String info = data[getStr];
		 buff.append(info+",");
	     ++getStr;
		 --len;
		 }
		
		 if(len==0){
			    System.out.println(Thread.currentThread().getName()+"截获数据完毕...");
				System.out.println(buff.toString());
				try {
					isEmtry.await();
				} catch (InterruptedException e) {
					e.printStackTrace();
				}			
		 }else{ 
			this.getData();		
		   }
		 isFull.signal();
		}finally{
			lock.unlock();
		}
	}
	public static void main(String[] args) {
	   final ConditionDemo condition = new ConditionDemo();
	//   final CountDownLatch latch = new CountDownLatch(1);
	 
	   for(int i=0;i<10;i++){
	   new Thread(new Runnable(){
		   
		  @Override
		  public void run(){
			condition.putData();
		//	latch.countDown();
		  }
	     }).start();
	   }
	   for(int i=0;i<100;i++){
	   new Thread(new Runnable(){
		   
			  @Override
			  public void run(){
				  try{
				  Thread.sleep((long)Math.random()*10000);
				  condition.getData();
				  }catch(InterruptedException e){
					  System.err.println(e.toString());
				  }
			  }
		   }).start();
	   }
	}
}


------- android培训、java培训、期待与您交流！ ----------





jonnxx
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
黑马程序员---线程并发库
程序员
05-20 807
软件包 java.util.concurrent 在并发编程中很常用的实用工具类。 请参见：            描述 接口摘要 BlockingDeque 支持两个附加操作的 Queue，这两个操作是：获取元素时等待双端队列变为非空；存储元素时等待双端队列中的空间变得可用。 BlockingQueue 支持两个附加操作的 Queue，这两个操作是
线程池ScheduledThreadPool
陈九礼
07-26 6911
创建ScheduleThreadPool
黑马程序员_线程池的作用
新手学习笔记
04-24 481
黑马IT训练营   线程池是jdk 1.5以后才有的，对原来多线程在性能上的提升。因为系统启动新线程，会与操作系统进行交互，所以启动新线程成本比较高。线程池就可以减低这种成本，提高性能。并且线程池还可以有效地控制系统中并发线程的最大数量，即线程池中的参数就决定了系统可以存在的并发线程的最大数量。 使用线程池来执行线程任务的步骤如下： 1、调用Executors类的静态工厂方法创建一个Ex
定时线程池ScheduledThreadPool
qq_33635619的博客
04-03 1165
1、定长线程池 ScheduledExecutorService es = Executors.newScheduledThreadPool(1); 1代表线程池的大小。 2、用法 // 线程一 es.scheduleAtFixedRate(() -> { try{ System.out.println("###############...
（Java线程池 三）Java的四种线程池之scheduledThreadPool
myQNUMNINE的博客
02-15 2333
系列文章目录 文章目录系列文章目录一、概念二、Java代码总结 一、概念 创建一个定长线程池，支持定时及周期性任务执行。 值得注意的是：创建scheduledThreadPool时，不是使用ExecutorService，而是使用ScheduledExecutorService 定时任务所用方法为：schedule(new Runnable(){}, long delay, TimeUnit unit) 周期任务所用的方法为：scheduleAtFixedRate(new Runnable(){},
黑马程序员_张孝祥_Java多线程与并发库 视频+代码+资料
10-29
根据给定文件的信息，我们可以提炼出以下关于Java多线程与并发库的相关知识点： ### Java多线程基础 1. **线程的概念**：在Java中，线程是程序执行流的基本单元。一个标准的Java应用程序至少有一个线程，即主...
黑马程序员–Java多线程讲解笔记
12-22
本文主要探讨了多线程的概念、应用场景以及Java中创建线程的两种方式。 首先，进程和线程是理解多线程的基础概念。进程是操作系统中正在执行的程序，每个进程都有其独立的内存空间和执行路径。线程则是进程中的执行...
Java多线程与并发库视频资源网盘链接
04-11
通过黑马程序员提供的《Java多线程与并发库》视频教程，你可以系统地学习并实践这些知识点，逐步成为一名精通Java并发编程的开发者。记得结合实际项目进行练习，理论与实践相结合，将更有利于技能的巩固和提升。
多线程高新(黑马程序员)
04-03
本文将深入探讨“多线程高新”这一主题，结合黑马程序员的课程内容，来阐述多线程的核心概念、优势、实现方式以及在实际应用中的注意事项。 首先，多线程是指在一个进程中同时执行多个线程，这些线程可以共享同一...
黑马程序员-java多线程技术01
03-25
本教程将聚焦于Java中的多线程技术，以“黑马程序员-java多线程技术01”为学习起点，探讨如何在Java中实现并管理线程。 首先，我们来理解什么是线程。线程是操作系统分配CPU时间的基本单元，一个进程中可以有多个...
线程池之ScheduledThreadPool学习
墨玉浮白的博客
04-24 1万+
简介 ScheduledThreadPool是一个能实现定时、周期性任务的线程池。 创建方法 public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) { return new ScheduledThreadPoolExecutor(corePoolSize); } 这...
Java高并发编程中ScheduledExecutorService的使用及详细介绍-刘宇
热门推荐
刘宇的博客
08-19 1万+
作者：刘宇。一、什么是ScheduledExecutorService？二、ScheduledThreadPoolExecutor中的方法1、构造方法2、schedule方法3、scheduleAtFixedRate方法4、scheduleWithFixedDelay方法5、setContinueExistingPeriodicTasksAfterShutdownPolicy方法6、setExecuteExistingDelayedTasksAfterShutdownPolicy方法三、练习
定时且周期性的任务研究II--ScheduledThreadPoolExecutor
victorzhzh
04-21 137
上一篇中我们看到了Timer的不足之处，本篇我们将围绕这些不足之处看看ScheduledThreadPoolExecutor是如何优化的。 为了研究方便我们需要两个类： public class Task1 implements Callable&lt;String&gt; { @Override public String call() throws Exception { ...
Timer和ScheduledThreadPoolExecutor的区别
blueman2012的专栏
07-27 1136
Timer和ScheduledThreadPoolExecutor的区别            Timer的主要方法有：// 安排在指定的时间执行void schedule(TimerTask task, Date time)// 安排在指定的时间开始以重复的延时执行void s
计划任务ScheduledExecutorService的使用
weixin_40472874的博客
08-05 2215
Java 中的计划任务 Timer 工具类提供了以计时器或计划任务的功能来实现按指定时间或时间间隔执行任务，但由于 Timer 工具类并不是以池 pool ，而是以队列的方式来管理线程的，所以在高并发的情况下运行效率较低，在新版 JDK 中提供了 SchedleExecutorService对象来解决效率与定时任务的功能。 ...
《黑马程序员》 读写锁的使用练习
青云志,我心不死,必度青天...
04-01 546
------- android培训、java培训、期待与您交流！ ----------/** * 读写锁 * 我们开启分别开启三个读的线程，分别开启三个写的线程 * 读的时候其它的线程可以读，但是其它的线程不可以写 * 写的时候其它的线程不可以写 */ public class ReadWriteLockDemo { public static void main(Strin
制造业运营生产一体化整体规划方案.pdf
08-11
制造业运营生产一体化整体规划方案.pdf
软件开发编程重要培训资料分享7软件开发编程开发技术资料.zip
08-11
软件开发编程重要培训资料分享7软件开发编程开发技术资料.zip
毕业设计，基于ASP+SqlServer开发的外观专利图像检索平台，内含完整源代码，数据库，毕业论文
最新发布
08-11
毕业设计，基于ASP+SqlServer开发的外观专利图像检索平台，内含完整源代码，数据库，毕业论文 随着Internet技术的发展，互联网在中国逐步普及,人们对网络的需求也日益增长,利用计算机实现外观专利图像检索平台的管理势在必行。本系统从初步调查开始，详细介绍了需求分析、流程和数据分析，并进行了系统总体结构设计和数据库设计. 系统采用Dreamweaver编写ASP脚本，SQL SERVER建立数据库，从界面简洁、实用的要求出发，完成了外观专利图像检索平台管理工作的主要部分，包括外观专利图像检索平台和用户的信息浏览,添加，修改，删除，查询，并且实现了一些变量的取值，保存，的计算，和统计。 外观专利图像检索平台作为一个新兴的产业近年来取得了迅速的发展，旅行社如雨后春笋遍布全国各省市、目前外观专利图像检索平台行业普遍存在着企业规模小，管理不规范等弱点。外观专利图像检索平台可以把各种外观专利图像检索平台分类存储管理通过网络实现共享，不仅方便快捷，而且不会因为人员流动影响企业的经营，是旅行社在激烈的市场竞争中的坚强后盾。 因此，本文就详细的设计了一个外观专利图像检索平台，把外观专利图像检
Java多线程与并发库高级技术解析
"张孝祥的Java多线程与并发库高级应用笔记涵盖了从传统线程技术到Java 5引入的并发库的广泛内容，旨在帮助已有基础的开发者提升Java线程技术。教程通过深入讲解各种线程同步和通信机制，如线程互斥、同步通信、共享...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值