Java线程和线程池

墨蓝 2021-12-10 13:27 563阅读 0赞

创建线程的方式:继承Thread 、 实现Runnable接口 、实现Callable接口(可以通过Future获取返回结果)

介绍一下通过Callable实现多线程:

  1. public class ThreadC implements Callable {
  2. public Object call() throws Exception {
  3. System.out.println("线程执行");
  4. return "线程返回结果";
  5. }
  6. public static void main(String []args){
  7. ThreadC threadC=new ThreadC();
  8. FutureTask futureTask=new FutureTask(threadC);
  9. new Thread(futureTask).start();
  10. try {
  11. Object obj=futureTask.get();
  12. System.out.println(obj);
  13. } catch (InterruptedException e) {
  14. e.printStackTrace();
  15. } catch (ExecutionException e) {
  16. e.printStackTrace();
  17. }
  18. }
  19. }
  20. //输出结果
  21. 线程执行
  22. 线程返回结果

线程之间的状态转换(线程的状态:创建 就绪 执行 阻塞 终止)

  1. ![20150309140927553][]

对于线程中常用的方法有:
sleep():当前线程休眠,但对象锁保持不放
wait():,通常在和notify()一起作用在synchronized方法中,在执行完后让线程进入等待队列
notify:唤醒在此对象监听器的线程,如果有多个则随机唤醒一个
yeild():线程让步,暂停当前线程,让同级或更高优先级线程执行
join():当前线程进入阻塞,等待其他线程终止
interrupt():中断线程信号

线程同步:
线程的特点 :可见性 有序性 在不同步处理情况下多个线程并发执行的时候造成执行顺序随机,变量数据不可靠

public class ThreadD{
public /*synchronized */ void print(String name){ //传入字符串,按字符输出
for(int i=0;i<name.length();i++){
System.out.print(name.charAt(i));
}
}
public static void main(String []args){
final ThreadD threadD=new ThreadD();
Thread a=new Thread(new Runnable() { //创建两个线程执行print()方法,预期输出lisizhangsan,不在print方法加synchronized时输出结果就会变得随机
public void run() {
threadD.print(“lisi”);
}
});
Thread b=new Thread(new Runnable() {
public void run() {
threadD.print(“zhangsan”);
}
});
a.start();
b.start();
}

}

synchronized关键字的作用域有二种:
1)是某个对象实例内,synchronized aMethod(){}可以防止多个线程同时访问这个对象的synchronized方法(如果一个对象有多个synchronized方法,只要一个线程访问了其中的一个synchronized方法,其它线程不能同时访问这个对象中任何一个synchronized方法)。这时,不同的对象实例的synchronized方法是不相干扰的。也就是说,其它线程照样可以同时访问相同类的另一个对象实例中的synchronized方法;
2)是某个类的范围,synchronized static aStaticMethod{}防止多个线程同时访问这个类中的synchronized static 方法。它可以对类的所有对象实例起作用。

2、除了方法前用synchronized关键字,synchronized关键字还可以用于方法中的某个区块中,表示只对这个区块的资源实行互斥访问。用法是: synchronized(this){/*区块*/},它的作用域是当前对象;

3、synchronized关键字是不能继承的,也就是说,基类的方法synchronized f(){} 在继承类中并不自动是synchronized f(){},而是变成了f(){}。继承类需要你显式的指定它的某个方法为synchronized方法;

该部分文字引入来源: 原文:https://blog.csdn.net/evankaka/article/details/44153709

如何启动三个线程按顺序打印ABC:

  1. public class ThreadB implements Runnable{
  2. private String name;
  3. private Object pre;
  4. private Object self;
  5. public ThreadB(String name, Object pre, Object self) {
  6. this.name = name;
  7. this.pre = pre;
  8. this.self = self;
  9. }
  10. public void run() {
  11. synchronized (pre){
  12. synchronized (self){
  13. System.out.println(name);
  14. self.notify();
  15. }
  16. try {
  17. pre.wait();
  18. } catch (InterruptedException e) {
  19. e.printStackTrace();
  20. }
  21. }
  22. }
  23. public static void main(String []args){
  24. Object a=new Object();
  25. Object b=new Object();
  26. Object c=new Object();
  27. ThreadB ta=new ThreadB("A",b,c);
  28. ThreadB tb=new ThreadB("B",c,a);
  29. ThreadB tc=new ThreadB("C",a,b);
  30. for(int i=0;i<10;i++){
  31. new Thread(ta).start();
  32. new Thread(tb).start();
  33. new Thread(tc).start();
  34. }
  35. }
  36. }

线程池原理
public ThreadPoolExecutor(int corePoolSize,
int maximumPoolSize,
long keepAliveTime,
TimeUnit unit,
BlockingQueue workQueue,
RejectedExecutionHandler handler)

corePoolSize:线程池核心线程数量

maximumPoolSize:线程池最大线程数量

keepAliverTime:当活跃线程数大于核心线程数时,空闲的多余线程最大存活时间

unit:存活时间的单位

workQueue:存放任务的队列

handler:超出线程范围和队列容量的任务的处理程序

线程池的实现原理 文字引入来源: https://www.cnblogs.com/dongguacai/p/6030187.html
提交一个任务到线程池中,线程池的处理流程如下:

1、判断线程池里的核心线程是否都在执行任务,如果不是(核心线程空闲或者还有核心线程没有被创建)则创建一个新的工作线程来执行任务。如果核心线程都在执行任务,则进入下个流程。

2、线程池判断工作队列是否已满,如果工作队列没有满,则将新提交的任务存储在这个工作队列里。如果工作队列满了,则进入下个流程。

3、判断线程池里的线程是否都处于工作状态,如果没有,则创建一个新的工作线程来执行任务。如果已经满了,则交给饱和策略来处理这个任务。

  1. ![è¿éåå¾çæè¿°][2012121931.jpg]

RejectedExecutionHandler:饱和策略
当队列和线程池都满了,说明线程池处于饱和状态,那么必须对新提交的任务采用一种特殊的策略来进行处理。这个策略默认配置是AbortPolicy,表示无法处理新的任务而抛出异常。JAVA提供了4中策略:

1、AbortPolicy:直接抛出异常

2、CallerRunsPolicy:只用调用所在的线程运行任务

3、DiscardOldestPolicy:丢弃队列里最近的一个任务,并执行当前任务。

4、DiscardPolicy:不处理,丢弃掉。

ExecutorService threadPool = Executors.newFixedThreadPool(3);// 创建可以容纳3个线程的线程池

ExecutorService threadPool = Executors.newCachedThreadPool();// 线程池的大小会根据执行的任务数动态分配

ExecutorService threadPool = Executors.newSingleThreadExecutor();// 创建单个线程的线程池,如果当前线程在执行任务时突然中断,则会创建一个新的线程替代它继续执行任务

ScheduledExecutorService threadPool = Executors.newScheduledThreadPool(3);// 效果类似于Timer定时器

发表评论

表情:
评论列表 (有 0 条评论,563人围观)

还没有评论,来说两句吧...

相关阅读

    相关 线线

    现在是多核的时代,面向多核编程很重要,因些基于java的并发和多线程编程很重要。 首先要提到的就是线程池,与每次需要创建线程相比,线程池可以降低创建线程的开销,这是因为线程池在

    相关 线线

    软件大师又要给弟子开小灶了,这次是线程和线程池。 软件大师正在闭目修炼, 最小的一名弟子慢慢走了进来。 大师,最近我在学习线程,有很多迷惑的地方。 说来听听,让

    相关 Java线线

    创建线程的方式:继承Thread   、 实现Runnable接口  、实现Callable接口(可以通过Future获取返回结果) 介绍一下通过Callable实现多线程: