java 并发一 基本的线程机制

最新推荐文章于 2020-04-03 22:19:29 发布
原创 最新推荐文章于 2020-04-03 22:19:29 发布 · 185 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#jav 线程 #线程池 #java 并发 #基本线程机制

本文深入探讨Java线程池的使用与管理，包括Executor框架、线程池类型如newCachedThreadPool、newFixedThreadPool和newSingleThreadExecutor的特性，以及线程工厂、后台线程、线程中断和异常处理等高级主题。
  1. Executor
    executor是java5 concurrent包下的执行器提供管理Thread功能,如下例子
public class ThreadPool {
	
	private static int num = 0;

	public static void main(String[] args) {
		//创建线程池
		ExecutorService e = Executors.newCachedThreadPool();
		Task tack = new Task();
		for (int i = 0; i < 1; i++) {
			e.execute(tack); //执行任务
		}
		e.shutdown(); //阻止执行新任务，已经启动的任务依旧会执行完成
		//e.execute(tack); 再次开启任务会抛出RejectedExecutionException
	}
	
	static class Task implements Runnable{

		@Override
		public void run() {
			// TODO Auto-generated method stub
			while(true) {
				if(num == 100)break;
				System.out.println(++num);
			}
			
		}
		
	}

}

我们在这使用了Executor的静态方法newCachedThreadPool创建了一个线程池对象ExecutorService,又调用了其execute方法执行了任务Tack

	/**
		* 返回了一个ThreadPoolExecutor对象(ExecutorService的子类)
		* 线程池下标从0开始,最大值为Integer.MAX_VALUE int 类型的最大值
		* 使用SynchronousQueue来存储任务
		*/
    public static ExecutorService newCachedThreadPool() {
        return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                      60L, TimeUnit.SECONDS,
                                      new SynchronousQueue<Runnable>());
    }

newCachedThreadPool方法其实就是new了一个ThreadPoolExecutor对象调用了其构造方法，设置了线程池的参数。相对这个设置了int 最大值的线程池,当然是用于不确定又多少个任务而设置的，当你明确的知道有多少个任务时,提供了newFixedThreadPool( int size)方法这样就不需要初始化大容量的线程池了

	public static void main(String[] args) {
		//创建线程池
		//ExecutorService e = Executors.newCachedThreadPool();
		//线程池大小固定5
		ExecutorService e = Executors.newFixedThreadPool(5);
		Task tack = new Task();
		for (int i = 0; i < 5; i++) {
			e.execute(tack); //执行任务
		}
		e.shutdown(); //阻止执行新任务，当已经启动的任务依旧会执行完成
		//e.execute(tack); 再次开启任务会抛出RejectedExecutionException
	}

有了newFixedThreadPool，我们就可以根据自己的需要去创建相对应大小的线程池了。需注意一点的是，线程是可以复用的，在完成了任务之后依旧会存在于线程池等待新的任务。
相对应的Executors还提供了singleThreadExecutor方法只创建大小为1的线程池,适用于单独的并且长期运行的线程

    public static ExecutorService newSingleThreadExecutor() {
        return new FinalizableDelegatedExecutorService
            (new ThreadPoolExecutor(1, 1,
                                    0L, TimeUnit.MILLISECONDS,
                                    new LinkedBlockingQueue<Runnable>()));
    }

如果向singleThreadExecutor提交了多个任务,那么这些任务将排队依次执行,singleThreadExecutor会根据提交的顺序序列化任务

  1. 从任务中产生返回值
    Runnable是执行独立的任务，但如果需要在执行完任务时能够得到一个返回值则任务类就需要实现Callable接口
	static class Task2 implements Callable<Integer>{

		public Integer call() throws Exception {
			// TODO Auto-generated method stub
			System.out.println("执行了callable");
			Thread.sleep(1000*6);
			return 1;
		}
		
	}
		public static void main(String[] args) throws InterruptedException, ExecutionException {
		ExecutorService es = Executors.newSingleThreadExecutor();
		Task2 task2 = new Task2();
		Future<Integer> future = es.submit(task2);
		int a = future.get();
		System.out.println(a);
		//e.submit(tack);
	}

ExecutorService 得submit方法接受一个任务并调用线程执行它,它返回一个Future对象,Future封装了call方法得返回值并提供get方法获取它。任务没有完成将一直阻塞在get方法这里。但为什么要提供一个Future对象来获取返回值,不能够直接取得返回值吗，原因时Future除了提供get方法获取返回值外，还提供着cancel(),isDone()，isCancelled()等方法，可以通过这些方法来判断是否取消任务还是继续等待

		ExecutorService es = Executors.newSingleThreadExecutor();
		Task2 task2 = new Task2();
		Future<Integer> future = es.submit(task2);
		if(future.isDone()) {
			int a = future.get();
			System.out.println("任务返回值"+a);
		}else {
			future.cancel(true);
			//int a = future.get();
			System.out.println("中断了");
		}

使用cancel方法就可以直接取消任务，如果任务没有执行，那么就不会执行任务,这样就不会一直阻塞在get方法这里。我们来看看Future得实现类FutureTask

public class FutureTask<V> implements RunnableFuture<V> 

public interface RunnableFuture<V> extends Runnable, Future<V>

其实FutureTask也实现了Runnable,那么我们几乎就可以想到,FutureTask的run方法肯定调用了call()方法并将返回值提供给get()方法获取

    public void run() {
        if (state != NEW ||
            !UNSAFE.compareAndSwapObject(this, runnerOffset,
                                         null, Thread.currentThread()))
            return;
        try {
            Callable<V> c = callable; //
            if (c != null && state == NEW) {
                V result;
                boolean ran;
                try {
                    result = c.call(); //执行任务取得结果
                    ran = true;
                } catch (Throwable ex) {
                    result = null;
                    ran = false;
                    setException(ex);
                }
                if (ran)
                    set(result);
            }
        } finally {
            // runner must be non-null until state is settled to
            // prevent concurrent calls to run()
            runner = null;
            // state must be re-read after nulling runner to prevent
            // leaked interrupts
            int s = state;
            if (s >= INTERRUPTING)
                handlePossibleCancellationInterrupt(s);
        }
    }
    public V get() throws InterruptedException, ExecutionException {
        int s = state;
        if (s <= COMPLETING)
            s = awaitDone(false, 0L);
        return report(s);
    }

可以看到Future其实也是一个Runnable，由run(）方法调用call()执行任务取得返回值,get()方法中，如果任务没有完成将阻塞一直等待到任务完成并将结果返回.

  1. 休眠
public class SleepTask implements Runnable {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		ExecutorService e = Executors.newCachedThreadPool();
		for (int i = 0; i < 4; i++) {
			e.execute(new SleepTask());
		}
		e.shutdown();
	}

	@Override
	public void run() {
		// TODO Auto-generated method stub
		Random r = new Random();
		int ran1 = r.nextInt(10);
		try {
			//Thread.sleep(ran1);
			TimeUnit.SECONDS.sleep(ran1);//其实也是调用的Thread.sleep();
			System.out.println(ran1+"秒");
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
	
	

}

java 5之后提供了TimeUnit枚举来代替了Thread.sleep ,当然除了sleep，还有join，wait,等方法并且还提供了时间的相互转换等方法

			long s = TimeUnit.SECONDS.toMinutes(60);//秒转分
			long f = TimeUnit.MINUTES.toHours(60);//分转小时
			TimeUnit.SECONDS.timedJoin(new Thread(runnable), 20);//将等待指定线程先执行完
			TimeUnit.SECONDS.timedWait(new Object(), 20);//指定锁,线程将阻塞，直到被唤醒或超时
  1. 后台线程(守护线程)
    后台线程时程序运行的时候在后台运行的线程,其不属于程序不可缺的部分,当所有的非后台线程完成时(注意时所有的,不仅仅指创建后台线程的父线程)后台线程会强制结束
public class DaemonThread implements Runnable{

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		/*ExecutorService es = Executors.newCachedThreadPool(new ThreadFactory())
		es*/
		Thread t = new Thread(new DaemonThread());
		t.setDaemon(true);
		t.start();
		
	}
	
	public void run() {
		System.out.println("执行了任务");
	}

}

如上就显式的开启了一个后台线程也就是守护线程，当所有的主线程全部结束时，那么jvm的线程也将结束，会强制杀死所有的后台线程。

  1. ThreadFactory
    线程工厂可以让你的线程池创建指定类型的线程，jdk提供了ThreadFactory接口来提供指定类型的线程的功能，我们先来看看ThreadFactory接口
public interface ThreadFactory {
	//只有一个方法,接收一个任务，返回一个线程对象
    Thread newThread(Runnable r);
}

public class DaemonThread implements Runnable,ThreadFactory{

	private int num = 0;
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		DaemonThread dt = new DaemonThread();
		ExecutorService es = Executors.newCachedThreadPool(dt);
		for (int i = 0; i < 9; i++) {
			es.execute(dt);
			
		}
		es.shutdown();
/*		Thread t = new Thread(new DaemonThread());
		t.setDaemon(false);
		t.start();*/
		
	}
	
	public void run() {
		try {
			TimeUnit.MILLISECONDS.sleep(10);//休息10毫秒
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}finally{
			System.out.println("强制结束是不会执行finally语句的"+ ++num);
		}
		System.out.println("执行了任务"+ ++num);
	}

	@Override
	public Thread newThread(Runnable r) {
		// TODO Auto-generated method stub
		Thread t = new Thread(r);
		t.setPriority(10);//设置优先级
		t.setDaemon(true);//设置为后台线程
		return t;
	}
}

如上我们就通过使用线程工厂来创建同一种类型的线程了,ExecutorService es所创建的线程都属于后台线程并且优先级最高，但所有的任务都休息了10毫秒，这将导致main线程先跑完,那么所有的后台线程都不会执行(这里注意当后台线程强制退出是不会执行finally语句的)

  1. 中断线程
public class InterruptThread implements Runnable{

	public static void main(String[] args) throws InterruptedException {
		// TODO Auto-generated method stub
		Thread t = new Thread(new InterruptThread());
		t.start();
		//t.interrupt(); 
		System.out.println(t.isInterrupted()); //返回t线程是否中断了
		t.interrupt();							//中断t线程
		System.out.println(t.isInterrupted());//
	}

	@Override
	public void run() {
		// TODO Auto-generated method stub 
		System.out.println(Thread.currentThread().getName()+"开始任务");
		try {
			Thread.interrupted(); //返回是否中断了线程，如果中断了返回true并清除中断标记,也就是不会中断线程了
			TimeUnit.MILLISECONDS.sleep(5);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
			System.out.println(Thread.currentThread().getName()+"线程被中断"+Thread.currentThread().isInterrupted());
		}
		System.out.println(Thread.currentThread().getName()+"结束任务");
	}

}

interrupt()会中断一个阻塞的线程,并抛出InterruptException 。isInterrupted()方法能够判断出该线程是否标记了中断状态，但在异常被捕获时会清除掉这个标记,这也可以理解catch 语句里当然也属于这个线程，它需要执行当然要清除标记不让它标记该线程已中断。Thread还有一个静态方法interrupted()它也是返回当前线程是否标记为中断

    public static boolean interrupted() {
        return currentThread().isInterrupted(true);//true表示确认清除标记，false不清除标记
    }

可以看到其实interrupted是调用的当前执行线程的isInterrupted方法，并会将标记清除掉。
注 ： 中断线程只抛出异常,并不会退出该线程

  1. 捕获异常
    由于线程的特性,各自分开,独立运行。所以并不能捕获从线程中逃逸的线程,也就是异常必须在run方法中处理.为了解决这个问题 java1.5提供了UncaughtExceptionHandler接口，它允许每个线程依附一个线程处理器，线程处理器可以取得改线程抛出的异常
public class ExceptinThread implements Runnable{

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		ExecutorService es = Executors.newCachedThreadPool(new ExceptionThreadFactory());
		es.execute(new ExceptinThread()); //执行任务
		es.shutdown();
	}

	@Override
	public void run() {
		// TODO Auto-generated method stub
		throw new RuntimeException("抛出了异常");
	}


}

class UncaughtException implements UncaugxianhtExceptionHandler{
	private Throwable throwable ;
	@Override
	public void uncaughtException(Thread t, Throwable e) {
		// TODO Auto-generated method stub
		System.out.println("caught"+e);
		throwable = e;
	}
}


class ExceptionThreadFactory implements ThreadFactory{

	@Override
	public Thread newThread(Runnable r) {
		// TODO Auto-generated method stub
		UncaughtException ue = new UncaughtException();
		Thread t = new Thread(r);
		t.setUncaughtExceptionHandler(ue); //设置线程处理器
		return t;
		
	}
}

UncaughtException 实现了UncaugxianhtExceptionHandler，这样我们就可以在uncaughtException方法中取得任务run中抛出的异常做进一步的处理，异常处理器可以由线程的setUncaughtExceptionHandler方法设置。

Java并发编程：多线程与锁机制
shejizuopin的博客
04-03 835
在Java编程中，并发编程是一个重要且复杂的领域。多线程与锁机制是并发编程中的核心概念，它们允许程序同时执行多个任务，提高程序的响应性和效率。然而，不正确的使用多线程和锁机制也可能导致数据不一致、死锁等问题。本文将结合优快云网站上的相关讨论，深入探讨Java并发编程中的多线程与锁机制，通过代码示例和表格分析，提供实用的解决技巧。
为什么直接杀死线程是不好的
云彩挂上的二叉树
06-22 6852
Wrote by mutouyun. (http://darkc.at/why-shouldnt-i-kill-a-thread/) 我们知道，windows里有个API叫TerminateThread，它可以干掉任何正在欢快小跑的线程。对应的，liunx里则是pthread_cancel（不是pthread_kill，这玩意本质是向线程发信号，而不是杀死线程）加上PTHREAD_CAN
TimeUnit类详解及其常见用法（详解timedWait、sleep方法）
02-15 2万+
一、是什么 TimeUnit 表示给定单元粒度的时间段。TimeUnit是java.util.concurrent下面的一个枚举类，它提供在给定单元中进行跨单元转换和执行计时及延迟操作的实用工具方法。 二、枚举类常量详细信息 1、NANOSECONDS：纳秒 2、MICROSECONDS：微妙 3、MILLISECONDS：毫秒 4、SECONDS：秒 5、MINUTES：分...
TimeUnit.SECONDS.timedJoin()不适用于同时超时控制多个线程
weixin_41780311的博客
12-26 3101
TimeUnit.SECONDS.timedJoin()属于线性超时控制，如果创建多个线程想用它控制所有新线程的执行时间是不可行的。通俗一点说就是该方法中使用的Thread.join只有一个，即使是在循环中使用了，也只能等其控制完第一个线程之后才能控制后续线程。下面看例子：例子中展示了新创建的9个线程，使用该方法进行超时控制 public static void main(String[] arg...
线程之join
wanghui115521的专栏
04-03 323
线程之join使用源码解析 使用 public static void main(String[] args) throws Exception { System.out.println("start"); Thread t = new Thread() { @Override public void run() { ...
多线程Join方法
A_Runner的博客
06-09 3139
天意怜幽草,人间重晩晴 如果同时有两个线程，线程A(主线程)和线程B。线程B的执行时间需要5秒，那么在线程A中调用线程B之后（并且让线程B执行完）则需要5秒，这时，你可以这样写 A.sleep(5000); //让线程睡5秒 但是，如果你不知道线程B需要执行多长时间，并且在A中需要使用到B中的结果，那么，这时你就可以使用join方法；下面是具体的例子； public class...
Java并发：基本的线程机制
12-22
一、实现一个简单的线程 public class LiftOff implements Runnable{ protected int countDown = 10; private static int taskCount = 0; private final int id = taskCount++; ...
通过java并发编程和线程安全实现一个线程安全的计数器.zip
01-03
通过Java并发编程和线程安全实现一个线程安全的计数器，不仅是对并发编程技术的一个很好的实践，也是对线程安全问题深入理解的重要途径。掌握这一技术对于开发高效、稳定、可扩展的多线程应用有着重要的意义。
【多线程编程】基于Synchronized与Lock的线程安全控制：Java并发编程中锁机制与线程通信技术解析
最新发布
10-10
适合人群：具备一定Java基础，熟悉多线程基本概念，工作1-3年的开发人员或希望深入理解并发编程原理的学习者； 使用场景及目标：①掌握多线程中锁的机制与线程通信原理；②理解synchronized与Lock的区别及应用场景...
Java多线程并发执行demo代码实例
08-18
今天，我们通过一个demo代码实例来学习Java多线程并发执行的实现。 知识点1：泛型 在上面的代码中，我们可以看到泛型的使用，例如`public abstract class MultiThread, T>`。泛型是Java 5中引入的一种机制，它可以...
Class -- 05 -- TimeUnit类常用方法解析
Gene Xu
08-12 3836
这次主要整理下Java中TimeUnit类的常用方法 一、TimeUnit类的定义 TimeUnit类是一个枚举类，主要用于时间颗粒度的转换与线程的延时 TimeUnit主要包含了以下几个枚举常量 SECONDS：秒 MINUTES：分 HOURS：时 DAYS：日 NANOSECONDS：纳秒，等于1∗10−9s1∗10−9s1 * 10^{-9}s MICROSECONDS：微秒，...
pthread_timedjoin,pthread_cond_timedwait
落羽的专栏
08-16 5739
前几天使用pthread_cond_timedwait和pthread_timedjoin_np始终超时，最后查到原因是使用clock_gettime不正确导致 pthread_timedjoin_np中的时间为绝对时间，而我使用的clock_gettime(CLOCK_MON
枚举 TimeUnit 使用和说明
随笔记录-分享&记忆
02-09 3963
long millis = TimeUnit.NANOSECONDS.toMillis(long duration); java.util.concurrent 枚举 TimeUnit java.lang.Object java.lang.EnumTimeUnit> java.util.concurrent.TimeUnit 所有已实现的接口： Serializab
TimeUnit使用和解析
shi2huang的博客
05-12 5672
https://blog.youkuaiyun.com/yuanyl/article/details/45098331http://www.bianceng.cn/Programming/Java/201312/38938.htm
TimeUnit的简略介绍
一屁小肥羊的专栏
12-01 3161
TimeUnit的简略介绍
Boost - 线程-boost timed_join用法
beattwo的专栏
05-06 1652
[color=green][i][b] Author:QQ174554431 [/b][/i][/color] [b]TestTimeJoin.h[/b] [code="c++"] #pragma once #include #include #include class TestTimeJoin { public: TestTimeJoin(void)...
TimeUnit
热门推荐
Robin Hu的专栏
11-04 3万+
public enum TimeUnit extends Enum TimeUnit 表示给定单元粒度的时间段，它提供在这些单元中进行跨单元转换和执行计时及延迟操作的实用工具方法。TimeUnit 不维护时间信息，但是有助于组织和使用可能跨各种上下文单独维护的时间表示形式。 TimeUnit 主要用于通知基于时间的方法如何解释给定的计时参数。 例如，如果 lock 不可用，则以下代码将在
异步任务-AsyncTack基本使用
张鹿鹿的专栏
09-01 1811
AsyncTask的基本使用方法 　　在Day25我们讲解了Handler, 可以实现子线程数据传递到主线程(UI线程) 中去, 这样可以解决一些网络下载, 文件传输等需要子线程的完成的工作, 但是它也有一个小瑕疵 , 就是封装性不够好, 那就今天我们就要来说一下AsyncTask 介绍一下如何使用1, 继承AsyncTaskpublic class MyTask extends AsyncT
Java并发编程：线程同步机制详解
Java 并发基础线程同步 Java 并发编程是指多个...Java 中的线程同步机制是并发编程的核心概念之一，它们之间的关系非常紧密。通过本章节的学习，可以更好地理解 Java 中的线程同步机制，并更好地应用于实际项目中。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值