Java线程和线程池学习笔记

Posted 2022-12-06 等待戈多儿

Java线程的使用方式最基础的来说只有两种：实现Runnable和Callable接口，继承Thread类实际也是间接实现了Runnable接口。两者的区别的是Runnable没有返回值，而Callable有返回值。

 

1.实现Runnable接口的线程：

class RunnableThread implements Runnable
		@Override
		public void run() 
			System.out.println("我是Runnable方式实现的线程，我没有返回值");
		
	

2.实现Callable接口的线程

class CallableThread<String> implements Callable<Object>
		@Override
		public Object call() throws Exception 
		return "我是Callable方式实现的线程，我就是返回值";
		
		 
	

3.继承Thread类的线程

因为Java是单继承的，所以慎重使用。

class ExtendsThread extends Thread
		 public void run() 	 
			 System.out.println("我是继承Thread方式实现的线程");
		 
	

Executor框架-线程池

任务是一组逻辑单元，而线程则是使任务异步执行的机制。Java类库中，任务执行的抽象不是Thread，而是Executor。

	void t0() throws InterruptedException, ExecutionException
		Callable<Object> c = new TestCallable("参数");
	 	Runnable r = new TestRunnable();
		 final ExecutorService pool = Executors.newFixedThreadPool(2);
		 pool.execute(r);
		 FutureTask<Object> task = new FutureTask<Object>(c);
		 pool.submit(task);
		 System.out.println(task.get());
		 pool.shutdown();
	
	/**
	 * Callable与FutureTask
	 */
	private List<FutureTask<Object>> tasks = new ArrayList<FutureTask<Object>>();
	void t1() throws InterruptedException, ExecutionException
		 final ExecutorService pool = Executors.newFixedThreadPool(2);
		 Callable<Object> c1 = new TestCallable("参数1...");
		 FutureTask<Object> task1 = new FutureTask<Object>(c1);
		 tasks.add(task1);
		 if (!pool.isShutdown()) //ExecutorService具有生命周期
			 pool.submit(task1);
		 
		 Callable<Object> c2 = new TestCallable("参数2...");
		 FutureTask<Object> task2 = new FutureTask<Object>(c2);
		 tasks.add(task2);
		 if (!pool.isShutdown()) 
			 pool.submit(task2);
		 
		 String res = "";
		 for(int i=0;i<tasks.size();i++)
			 res+=tasks.get(i).get();
		 
		 System.out.println("并行运算的结果："+res);
		 pool.shutdown();
	
	
	/**
	 * Callable与ExecutorCompletionService
	 * 调用CompletionService的take方法是，会返回按完成顺序放回任务的结果，
	    CompletionService内部维护了一个阻塞队列BlockingQueue
	 */
	private CompletionService<Object> completionService; 
	void t2() throws InterruptedException, ExecutionException
		 final ExecutorService pool = Executors.newFixedThreadPool(2);
		 completionService = new ExecutorCompletionService<Object>(pool);
		 Callable<Object> c1 = new TestCallable("参数3...");
		 if (!pool.isShutdown()) //ExecutorService具有生命周期
			 completionService.submit(c1);
		 
		 Callable<Object> c2 = new TestCallable("参数4...");
		 if (!pool.isShutdown()) 
			 completionService.submit(c2);
		 
		 String res = "";
		 for(int i=0;i<2;i++)
			 res+=completionService.take().get();
		 
		 System.out.println("并行运算的结果："+res);
		 pool.shutdown();
	
	/**
	 * 设置限时
	 * @throws InterruptedException
	 * @throws ExecutionException
	 * @throws TimeoutException
	 */
	void t3() throws InterruptedException, ExecutionException
		Callable<Object> c = new TestTimeoutCallable("参数...");
		 final ExecutorService pool = Executors.newFixedThreadPool(2);
		 FutureTask<Object> task = new FutureTask<Object>(c);
		 pool.submit(task);
		 try 
			System.out.println(task.get(500,TimeUnit.MILLISECONDS));
			 //设置现实，超过限时将不执行,并抛出异常，参数换为500和5000，效果不同
		 catch (TimeoutException e) 
			task.cancel(true);
			e.printStackTrace();
		
		
		 pool.shutdown(); 
	
	/**
	 * 通过调用设置限时
	 * @throws InterruptedException
	 * @throws ExecutionException
	 * @throws TimeoutException
	 */
	private List<TestTimeoutCallable> ttcl = new ArrayList<TestTimeoutCallable>();
	void t4()
		Callable<Object> c = new TestTimeoutCallable("参数...");
		 final ExecutorService pool = Executors.newFixedThreadPool(2);
		 ttcl.add((TestTimeoutCallable) c);
		 List<Future<Object>> futures;
		try 
			futures = pool.invokeAll(ttcl,5000,TimeUnit.MILLISECONDS);
			//参数换为500和5000，效果不同
		
		 for(Future<Object> f:futures)
			 try 
				System.out.println(f.get());
			 catch (InterruptedException e) 		 
				e.printStackTrace();
			 catch (ExecutionException e) 			 
				e.printStackTrace();
			finally
				pool.shutdown();
			
		 
		 catch (InterruptedException e) 
			e.printStackTrace();
		finally
			pool.shutdown();
		
		 pool.shutdown(); 
	
	static class TestCallable implements Callable<Object>
		private String param;
		TestCallable(String param) 
			this.param = param;
		
		@Override
		public Object call() throws Exception 
			System.out.println("callable线程..."+param);
			Object p = new String(param);
			return p;
		
		
	
	static class TestTimeoutCallable implements Callable<Object>
		private String param;
		TestTimeoutCallable(String param) 
			this.param = param;
		
		@Override
		public Object call() throws Exception 
			System.out.println("callable线程..."+param);
			Object p = new String(param);
			Thread.sleep(2000);//模拟业务计算，耗时2000毫秒
			return p;
		
		
	
	
	static class TestRunnable implements Runnable
		@Override
		public void run() 
			System.out.println("runnable线程...");