正文
java并发编程详解代码 java并发编程实战
小程序:扫一扫查出行
【扫一扫了解最新限行尾号】
复制小程序
【扫一扫了解最新限行尾号】
复制小程序
java并发常识
1.java并发编程是什么
1, 保证线程安全的三种方法: a, 不要跨线程访问共享变量b, 使共享变量是final类型的c, 将共享变量的操作加上同步 2, 一开始就将类设计成线程安全的, 比在后期重新修复它,更容易。
3, 编写多线程程序, 首先保证它是正确的, 其次再考虑性能。 4, 无状态或只读对象永远是线程安全的。
5, 不要将一个共享变量 *** 在多线程环境下(无同步或不可变性保护) 6, 多线程环境下的延迟加载需要同步的保护, 因为延迟加载会造成对象重复实例化 7, 对于volatile声明的数值类型变量进行运算, 往往是不安全的(volatile只能保证可见性,不能保证原子性)。 详见volatile原理与技巧中, 脏数据问题讨论。
8, 当一个线程请求获得它自己占有的锁时(同一把锁的嵌套使用), 我们称该锁为可重入锁。在jdk1。
5并发包中, 提供了可重入锁的java实现-ReentrantLock。 9, 每个共享变量,都应该由一个唯一确定的锁保护。
创建与变量相同数目的ReentrantLock, 使他们负责每个变量的线程安全。 10,虽然缩小同步块的范围, 可以提升系统性能。
但在保证原子性的情况下, 不可将原子操作分解成多个synchronized块。 11, 在没有同步的情况下, 编译器与处理器运行时的指令执行顺序可能完全出乎意料。
原因是, 编译器或处理器为了优化自身执行效率, 而对指令进行了的重排序(reordering)。 12, 当一个线程在没有同步的情况下读取变量, 它可能会得到一个过期值, 但是至少它可以看到那个线程在当时设定的一个真实数值。
而不是凭空而来的值。 这种安全保证, 称之为最低限的安全性(out-of-thin-air safety) 在开发并发应用程序时, 有时为了大幅度提高系统的吞吐量与性能, 会采用这种无保障的做法。
但是针对, 数值的运算, 仍旧是被否决的。 13, volatile变量,只能保证可见性, 无法保证原子性。
14, 某些耗时较长的网络操作或IO, 确保执行时, 不要占有锁。 15, 发布(publish)对象, 指的是使它能够被当前范围之外的代码所使用。
(引用传递)对象逸出(escape), 指的是一个对象在尚未准备好时将它发布。 原则: 为防止逸出, 对象必须要被完全构造完后, 才可以被发布(最好的解决方式是采用同步) this关键字引用对象逸出 例子: 在构造函数中, 开启线程, 并将自身对象this传入线程, 造成引用传递。
而此时, 构造函数尚未执行完, 就会发生对象逸出了。 16, 必要时, 使用ThreadLocal变量确保线程封闭性(封闭线程往往是比较安全的, 但一定程度上会造成性能损耗)封闭对象的例子在实际使用过程中, 比较常见, 例如 hibernate openSessionInView机制, jdbc的connection机制。
17, 单一不可变对象往往是线程安全的(复杂不可变对象需要保证其内部成员变量也是不可变的)良好的多线程编程习惯是: 将所有的域都声明为final, 除非它们是可变的。
2.Java线程并发协作是什么
线程发生死锁可能性很小,即使看似可能发生死锁的代码,在运行时发生死锁的可能性也是小之又小。
发生死锁的原因一般是两个对象的锁相互等待造成的。 在《Java线程:线程的同步与锁》一文中,简述死锁的概念与简单例子,但是所给的例子是不完整的,这里给出一个完整的例子。
/** * Java线程:并发协作-死锁 * * @author Administrator 2009-11-4 22:06:13 */ public class Test { public static void main(String[] args) { DeadlockRisk dead = new DeadlockRisk(); MyThread t1 = new MyThread(dead, 1, 2); MyThread t2 = new MyThread(dead, 3, 4); MyThread t3 = new MyThread(dead, 5, 6); MyThread t4 = new MyThread(dead, 7, 8); t1。 start(); t2。
start(); t3。start(); t4。
start(); } } class MyThread extends Thread { private DeadlockRisk dead; private int a, b; MyThread(DeadlockRisk dead, int a, int b) { this。 dead = dead; this。
a = a; this。b = b; } @Override public void run() { dead。
read(); dead。write(a, b); } } class DeadlockRisk { private static class Resource { public int value; }。
3.如何学习Java高并发
1.学习 *** 并发框架的使用,如ConcurrentHashMAP,CopyOnWriteArrayList/Set等2.几种并发锁的使用以及线程同步与互斥,如ReentainLock,synchronized,Lock,CountDownLatch,Semaphore等3.线程池如Executors,ThreadPoolExecutor等4.Runable,Callable,RescureTask,Future,FutureTask等5.Fork-Join框架以上基本包含完了,如有缺漏请原谅。
4.并发编程的Java抽象有哪些呢
一、机器和OS级别抽象 (1)冯诺伊曼模型 经典的顺序化计算模型,貌似可以保证顺序化一致性,但是没有哪个现代的多处理架构会提供顺序一致性,冯氏模型只是现代多处理器行为的模糊近似。
这个计算模型,指令或者命令列表改变内存变量直接契合命令编程泛型,它以显式的算法为中心,这和声明式编程泛型有区别。 就并发编程来说,会显著的引入时间概念和状态依赖 所以所谓的函数式编程可以解决其中的部分问题。
(2)进程和线程 进程抽象运行的程序,是操作系统资源分配的基本单位,是资源cpu,内存,IO的综合抽象。 线程是进程控制流的多重分支,它存在于进程里,是操作系统调度的基本单位,线程之间同步或者异步执行,共享进程的内存地址空间。
(3)并发与并行 并发,英文单词是concurrent,是指逻辑上同时发生,有人做过比喻,要完成吃完三个馒头的任务,一个人可以这个馒头咬一口,那个馒头咬一口,这样交替进行,最后吃完三个馒头,这就是并发,因为在三个馒头上同时发生了吃的行为,如果只是吃完一个接着吃另一个,这就不是并发了,是排队,三个馒头如果分给三个人吃,这样的任务完成形式叫并行,英文单词是parallel。 回到计算机概念,并发应该是单CPU时代或者单核时代的说法,这个时候CPU要同时完成多任务,只能用时间片轮转,在逻辑上同时发生,但在物理上是串行的。
现在大多数计算机都是多核或者多CPU,那么现在的多任务执行方式就是物理上并行的。 为了从物理上支持并发编程,CPU提供了相应的特殊指令,比如原子化的读改写,比较并交换。
(4)平台内存模型 在可共享内存的多处理器体系结构中,每个处理器都有它自己的缓存,并且周期性的与主存同步,为什么呢?因为处理器通过降低一致性来换取性能,这和CAP原理通过降低一致性来获取伸缩性有点类似,所以大量的数据在CPU的寄存器中被计算,另外CPU和编译器为了性能还会乱序执行,但是CPU会提供存储关卡指令来保证存储的同步,各种平台的内存模型或者同步指令可能不同,所以这里必须介入对内存模型的抽象,JMM就是其中之一。 二、编程模型抽象 (1)基于线程模型 (2)基于Actor模型 (3)基于STM软件事务内存 …… Java体系是一个基于线程模型的本质编程平台,所以我们主要讨论线程模型。
三、并发单元抽象 大多数并发应用程序都是围绕执行任务进行管理的,任务是抽象,离散的工作单元,所以编写并发程序,首要工作就是提取和分解并行任务。 一旦任务被抽象出来,他们就可以交给并发编程平台去执行,同时在任务抽象还有另一个重要抽象,那就是生命周期,一个任务的开始,结束,返回结果,都是生命周期中重要的阶段。
那么编程平台必须提供有效安全的管理任务生命周期的API。 四、线程模型 线程模型是Java的本质模型,它无所不在,所以Java开发必须搞清楚底层线程调度细节,不搞清楚当然就会有struts1,struts2的原理搞不清楚的基本灾难(比如在struts2的action中塞入状态,把struts2的action配成单例)。
用线程来抽象并发编程,是比较低级别的抽象,所以难度就大一些,难度级别会根据我们的任务特点有以下几个类别 (1)任务非常独立,不共享,这是最理想的情况,编程压力为0。 (2)共享数据,压力开始增大,必须引入锁,Volatile变量,问题有活跃度和性能危险。
(3)状态依赖,压力再度增大,这时候我们基本上都是求助jdk 提供的同步工具。 五、任务执行 任务是一个抽象体,如果被抽象了出来,下一步就是交给编程平台去执行,在Java中,描述任务的一个基本接口是Runnable,可是这个抽象太有限了,它不能返回值和抛受检查异常,所以Jdk5。
0有另外一个高级抽象Callable。 任务的执行在Jdk中也是一个底级别的Thread,线程有好处,但是大量线程就有大大的坏处,所以如果任务量很多我们并不能就创建大量的线程去服务这些任务,那么Jdk5。
0在任务执行上做了抽象,将任务和任务执行隔离在接口背后,这样我们就可以引入比如线程池的技术来优化执行,优化线程的创建。 任务是有生命周期的,所以Jdk5。
0提供了Future这个对象来描述对象的生命周期,通过这个future可以取到任务的结果甚至取消任务。 六、锁 当然任务之间共享了数据,那么要保证数据的安全,必须提供一个锁机制来协调状态,锁让数据访问原子,但是引入了串行化,降低了并发度,锁是降低程序伸缩性的原罪,锁是引入上下文切换的主要原罪,锁是引入死锁,活锁,优先级倒置的绝对原罪,但是又不能没有锁,在Java中,锁是一个对象,锁提供原子和内存可见性,Volatile变量提供内存可见性不提供原子,原子变量提供可见性和原子,通过原子变量可以构建无锁算法和无锁数据结构,但是这需要高高手才可以办到。
5.Java高并发入门要怎么学习
1、如果不使用框架,纯原生Java编写,是需要了解Java并发编程的,主要就是学习Doug Lea开发的那个java.util.concurrent包下面的API;2、如果使用框架,那么我的理解,在代码层面确实不会需要太多的去关注并发问题,反而是由于高并发会给系统造成很大压力,要在缓存、数据库操作上要多加考虑。
3、但是即使是使用框架,在工作中还是会用到多线程,就拿常见的CRUD接口来说,比如一个非常耗时的save接口,有多耗时呢?我们假设整个save执行完要10分钟,所以,在save的时候,就需要采用异步的方式,也就是单独用一个线程去save,然后直接给前端返回200。
6.Java如何进行并发多连接socket编程呢
Java多个客户端同时连接服务端,在现实生活中用得比较多。
同时执行多项任务,第一想到的当然是多线程了。下面用多线程来实现并发多连接。
import java。。
*; import java。io。
*; public class ThreadServer extends Thread { private Socket client; public ThreadServer(Socket c) { this。 client=c; } public void run() { try { BufferedReader in=new BufferedReader(new InputStreamReader(client。
getInputStream())); PrintWriter out=new PrintWriter(client。 getOutputStream()); Mutil User but can't parallel while (true) { String str=in。
readLine(); System。out。
println(str); out。 println("has receive。
"); out。
flush(); if (str。equals("end")) break; } client。
close(); } catch (IOException ex) { } finally { } } public static void main(String[] args)throws IOException { ServerSocket server=new ServerSocket(8000); while (true) { transfer location change Single User or Multi User ThreadServer mu=new ThreadServer(server。 accept()); mu。
start(); } } }J。
7.如何掌握java多线程,高并发,大数据方面的技能
线程:同一类线程共享代码和数据空间,每个线程有独立的运行栈和程序计数器(PC),线程切换开销小。
(线程是cpu调度的最小单位)线程和进程一样分为五个阶段:创建、就绪、运行、阻塞、终止。多进程是指操作系统能同时运行多个任务(程序)。
多线程是指在同一程序中有多个顺序流在执行。在java中要想实现多线程,有两种手段,一种是继续Thread类,另外一种是实现Runable接口.(其实准确来讲,应该有三种,还有一种是实现Callable接口,并与Future、线程池结合使用。
8.java工程师需要掌握哪些知识
1.Core Java,就是Java基础、JDK的类库,很多童鞋都会说,JDK我懂,但是懂还不足够,知其然还要知其所以然,JDK的源代码写的非常好,要经常查看,对使用频繁的类,比如String, *** 类(List,Map,Set)等数据结构要知道它们的实现,不同的 *** 类有什么区别,然后才能知道在一个具体的场合下使用哪个 *** 类更适合、更高效,这些内容直接看源代码就OK了2.多线程并发编程,现在并发几乎是写服务端程序必须的技术,那对Java中的多线程就要有足够的熟悉,包括对象锁机制、synchronized关键字,concurrent包都要非常熟悉,这部分推荐你看看《Java并发编程实践》这本书,讲解的很详细3.I/O,Socket编程,首先要熟悉Java中Socket编程,以及I/O包,再深入下去就是Java NIO,再深入下去是操作系统底层的Socket实现,了解Windows和Linux中是怎么实现socket的4.JVM的一些知识,不需要熟悉,但是需要了解,这是Java的本质,可以说是Java的母体, 了解之后眼界会更宽阔,比如Java内存模型(会对理解Java锁、多线程有帮助)、字节码、JVM的模型、各种垃圾收集器以及选择、JVM的执行参数(优化JVM)等等,这些知识在《深入Java虚拟机》这本书中都有详尽的解释,或者去oracle网站上查看具体版本的JVM规范.5.一些常用的设计模式,比如单例、模板方法、代理、适配器等等,以及在Core Java和一些Java框架里的具体场景的实现,这个可能需要慢慢积累,先了解有哪些使用场景,见得多了,自己就自然而然会去用。
6.常用数据库(Oracle、MySQL等)、SQL语句以及一般的优化7.JavaWeb开发的框架,比如Spring、iBatis等框架,同样他们的原理才是最重要的,至少要知道他们的大致原理。8.其他一些有名的用的比较多的开源框架和包,ty网络框架,Apache mon的N多包,Google的Guava等等,也可以经常去Github上找一些代码看看。
暂时想到的就这么多吧,1-4条是Java基础,全部的这些知识没有一定的时间积累是很难搞懂的,但是了解了之后会对Java有个彻底的了解,5和6是需要学习的额外技术,7-8是都是基于1-4条的,正所谓万变不离其宗,前4条就是Java的灵魂所在,希望能对你有所帮助9.(补充)学会使用Git。如果你还在用SVN的话,赶紧投入Git的怀抱吧。
9.java 多线程的并发到底是什么意思
一、多线程1、操作系统有两个容易混淆的概念,进程和线程。
进程:一个计算机程序的运行实例,包含了需要执行的指令;有自己的独立地址空间,包含程序内容和数据;不同进程的地址空间是互相隔离的;进程拥有各种资源和状态信息,包括打开的文件、子进程和信号处理。线程:表示程序的执行流程,是CPU调度执行的基本单位;线程有自己的程序计数器、寄存器、堆栈和帧。
同一进程中的线程共用相同的地址空间,同时共享进进程锁拥有的内存和其他资源。2、Java标准库提供了进程和线程相关的API,进程主要包括表示进程的java.lang.Process类和创建进程的java.lang.ProcessBuilder类;表示线程的是java.lang.Thread类,在虚拟机启动之后,通常只有Java类的main方法这个普通线程运行,运行时可以创建和启动新的线程;还有一类守护线程(damon thread),守护线程在后台运行,提供程序运行时所需的服务。
当虚拟机中运行的所有线程都是守护线程时,虚拟机终止运行。3、线程间的可见性:一个线程对进程 *** 享的数据的修改,是否对另一个线程可见可见性问题:a、CPU采用时间片轮转等不同算法来对线程进行调度[java] view plaincopypublic class IdGenerator{ private int value = 0; public int getNext(){ return value++; } } 对于IdGenerator的getNext()方法,在多线程下不能保证返回值是不重复的:各个线程之间相互竞争CPU时间来获取运行机会,CPU切换可能发生在执行间隙。
以上代码getNext()的指令序列:CPU切换可能发生在7条指令之间,多个getNext的指令交织在一起。
「高并发」两种异步模型与深度解析Future接口-
大家好,我是冰河~~
本文有点长,但是满满的干货,以实际案例的形式分析了两种异步模型,并从源码角度深度解析Future接口和FutureTask类,希望大家踏下心来,打开你的IDE,跟着文章看源码,相信你一定收获不小!
在Java的并发编程中,大体上会分为两种异步编程模型,一类是直接以异步的形式来并行运行其他的任务,不需要返回任务的结果数据。一类是以异步的形式运行其他任务,需要返回结果。
1.无返回结果的异步模型
无返回结果的异步任务,可以直接将任务丢进线程或线程池中运行,此时,无法直接获得任务的执行结果数据,一种方式是可以使用回调方法来获取任务的运行结果。
具体的方案是:定义一个回调接口,并在接口中定义接收任务结果数据的方法,具体逻辑在回调接口的实现类中完成。将回调接口与任务参数一同放进线程或线程池中运行,任务运行后调用接口方法,执行回调接口实现类中的逻辑来处理结果数据。这里,给出一个简单的示例供参考。
便于接口的通用型,这里为回调接口定义了泛型。
回调接口的实现类主要用来对任务的返回结果进行相应的业务处理,这里,为了方便演示,只是将结果数据返回。大家需要根据具体的业务场景来做相应的分析和处理。
任务的执行类是具体执行任务的类,实现Runnable接口,在此类中定义一个回调接口类型的成员变量和一个String类型的任务参数(模拟任务的参数),并在构造方法中注入回调接口和任务参数。在run方法中执行任务,任务完成后将任务的结果数据封装成TaskResult对象,调用回调接口的方法将TaskResult对象传递到回调方法中。
到这里,整个大的框架算是完成了,接下来,就是测试看能否获取到异步任务的结果了。
在测试类中,使用Thread类创建一个新的线程,并启动线程运行任务。运行程序最终的接口数据如下所示。
大家可以细细品味下这种获取异步结果的方式。这里,只是简单的使用了Thread类来创建并启动线程,也可以使用线程池的方式实现。大家可自行实现以线程池的方式通过回调接口获取异步结果。
2.有返回结果的异步模型
尽管使用回调接口能够获取异步任务的结果,但是这种方式使用起来略显复杂。在JDK中提供了可以直接返回异步结果的处理方案。最常用的就是使用Future接口或者其实现类FutureTask来接收任务的返回结果。
使用Future接口往往配合线程池来获取异步执行结果,如下所示。
运行结果如下所示。
FutureTask类既可以结合Thread类使用也可以结合线程池使用,接下来,就看下这两种使用方式。
结合Thread类的使用示例如下所示。
运行结果如下所示。
结合线程池的使用示例如下。
运行结果如下所示。
可以看到使用Future接口或者FutureTask类来获取异步结果比使用回调接口获取异步结果简单多了。注意:实现异步的方式很多,这里只是用多线程举例。
接下来,就深入分析下Future接口。
1.Future接口
Future是JDK1.5新增的异步编程接口,其源代码如下所示。
可以看到,在Future接口中,总共定义了5个抽象方法。接下来,就分别介绍下这5个方法的含义。
取消任务的执行,接收一个boolean类型的参数,成功取消任务,则返回true,否则返回false。当任务已经完成,已经结束或者因其他原因不能取消时,方法会返回false,表示任务取消失败。当任务未启动调用了此方法,并且结果返回true(取消成功),则当前任务不再运行。如果任务已经启动,会根据当前传递的boolean类型的参数来决定是否中断当前运行的线程来取消当前运行的任务。
判断任务在完成之前是否被取消,如果在任务完成之前被取消,则返回true;否则,返回false。
这里需要注意一个细节:只有任务未启动,或者在完成之前被取消,才会返回true,表示任务已经被成功取消。其他情况都会返回false。
判断任务是否已经完成,如果任务正常结束、抛出异常退出、被取消,都会返回true,表示任务已经完成。
当任务完成时,直接返回任务的结果数据;当任务未完成时,等待任务完成并返回任务的结果数据。
当任务完成时,直接返回任务的结果数据;当任务未完成时,等待任务完成,并设置了超时等待时间。在超时时间内任务完成,则返回结果;否则,抛出TimeoutException异常。
2.RunnableFuture接口
Future接口有一个重要的子接口,那就是RunnableFuture接口,RunnableFuture接口不但继承了Future接口,而且继承了java.lang.Runnable接口,其源代码如下所示。
这里,问一下,RunnableFuture接口中有几个抽象方法?想好了再说!哈哈哈。。。
这个接口比较简单run()方法就是运行任务时调用的方法。
3.FutureTask类
FutureTask类是RunnableFuture接口的一个非常重要的实现类,它实现了RunnableFuture接口、Future接口和Runnable接口的所有方法。FutureTask类的源代码比较多,这个就不粘贴了,大家自行到java.util.concurrent下查看。
(1)FutureTask类中的变量与常量
在FutureTask类中首先定义了一个状态变量state,这个变量使用了volatile关键字修饰,这里,大家只需要知道volatile关键字通过内存屏障和禁止重排序优化来实现线程安全,后续会单独深度分析volatile关键字是如何保证线程安全的。紧接着,定义了几个任务运行时的状态常量,如下所示。
其中,代码注释中给出了几个可能的状态变更流程,如下所示。
接下来,定义了其他几个成员变量,如下所示。
又看到我们所熟悉的Callable接口了,Callable接口那肯定就是用来调用call()方法执行具体任务了。
看一下WaitNode类的定义,如下所示。
可以看到,WaitNode类是FutureTask类的静态内部类,类中定义了一个Thread成员变量和指向下一个WaitNode节点的引用。其中通过构造方法将thread变量设置为当前线程。
(2)构造方法
接下来,是FutureTask的两个构造方法,比较简单,如下所示。
(3)是否取消与完成方法
继续向下看源码,看到一个任务是否取消的方法,和一个任务是否完成的方法,如下所示。
这两方法中,都是通过判断任务的状态来判定任务是否已取消和已完成的。为啥会这样判断呢?再次查看FutureTask类中定义的状态常量发现,其常量的定义是有规律的,并不是随意定义的。其中,大于或者等于CANCELLED的常量为CANCELLED、INTERRUPTING和INTERRUPTED,这三个状态均可以表示线程已经被取消。当状态不等于NEW时,可以表示任务已经完成。
通过这里,大家可以学到一点:以后在编码过程中,要按照规律来定义自己使用的状态,尤其是涉及到业务中有频繁的状态变更的操作,有规律的状态可使业务处理变得事半功倍,这也是通过看别人的源码设计能够学到的,这里,建议大家还是多看别人写的优秀的开源框架的源码。
(4)取消方法
我们继续向下看源码,接下来,看到的是cancel(boolean)方法,如下所示。
接下来,拆解cancel(boolean)方法。在cancel(boolean)方法中,首先判断任务的状态和CAS的操作结果,如果任务的状态不等于NEW或者CAS的操作返回false,则直接返回false,表示任务取消失败。如下所示。
接下来,在try代码块中,首先判断是否可以中断当前任务所在的线程来取消任务的运行。如果可以中断当前任务所在的线程,则以一个Thread临时变量来指向运行任务的线程,当指向的变量不为空时,调用线程对象的interrupt()方法来中断线程的运行,最后将线程标记为被中断的状态。如下所示。
这里,发现变更任务状态使用的是UNSAFE.putOrderedInt()方法,这个方法是个什么鬼呢?点进去看一下,如下所示。
可以看到,又是一个本地方法,嘿嘿,这里先不管它,后续文章会详解这些方法的作用。
接下来,cancel(boolean)方法会进入finally代码块,如下所示。
可以看到在finallly代码块中调用了finishCompletion()方法,顾名思义,finishCompletion()方法表示结束任务的运行,接下来看看它是如何实现的。点到finishCompletion()方法中看一下,如下所示。
在finishCompletion()方法中,首先定义一个for循环,循环终止因子为waiters为null,在循环中,判断CAS操作是否成功,如果成功进行if条件中的逻辑。首先,定义一个for自旋循环,在自旋循环体中,唤醒WaitNode堆栈中的线程,使其运行完成。当WaitNode堆栈中的线程运行完成后,通过break退出外层for循环。接下来调用done()方法。done()方法又是个什么鬼呢?点进去看一下,如下所示。
可以看到,done()方法是一个空的方法体,交由子类来实现具体的业务逻辑。
当我们的具体业务中,需要在取消任务时,执行一些额外的业务逻辑,可以在子类中覆写done()方法的实现。
(5)get()方法
继续向下看FutureTask类的代码,FutureTask类中实现了两个get()方法,如下所示。
没参数的get()方法为当任务未运行完成时,会阻塞,直到返回任务结果。有参数的get()方法为当任务未运行完成,并且等待时间超出了超时时间,会TimeoutException异常。
两个get()方法的主要逻辑差不多,一个没有超时设置,一个有超时设置,这里说一下主要逻辑。判断任务的当前状态是否小于或者等于COMPLETING,也就是说,任务是NEW状态或者COMPLETING,调用awaitDone()方法,看下awaitDone()方法的实现,如下所示。
接下来,拆解awaitDone()方法。在awaitDone()方法中,最重要的就是for自旋循环,在循环中首先判断当前线程是否被中断,如果已经被中断,则调用removeWaiter()将当前线程从堆栈中移除,并且抛出InterruptedException异常,如下所示。
接下来,判断任务的当前状态是否完成,如果完成,并且堆栈句柄不为空,则将堆栈中的当前线程设置为空,返回当前任务的状态,如下所示。
当任务的状态为COMPLETING时,使当前线程让出CPU资源,如下所示。
如果堆栈为空,则创建堆栈对象,如下所示。
如果queued变量为false,通过CAS操作为queued赋值,如果awaitDone()方法传递的timed参数为true,则计算超时时间,当时间已超时,则在堆栈中移除当前线程并返回任务状态,如下所示。如果未超时,则重置超时时间,如下所示。
如果不满足上述的所有条件,则将当前线程设置为等待状态,如下所示。
接下来,回到get()方法中,当awaitDone()方法返回结果,或者任务的状态不满足条件时,都会调用report()方法,并将当前任务的状态传递到report()方法中,并返回结果,如下所示。
看来,这里还要看下report()方法啊,点进去看下report()方法的实现,如下所示。
可以看到,report()方法的实现比较简单,首先,将outcome数据赋值给x变量,接下来,主要是判断接收到的任务状态,如果状态为NORMAL,则将x强转为泛型类型返回;当任务的状态大于或者等于CANCELLED,也就是任务已经取消,则抛出CancellationException异常,其他情况则抛出ExecutionException异常。
至此,get()方法分析完成。注意:一定要理解get()方法的实现,因为get()方法是我们使用Future接口和FutureTask类时,使用的比较频繁的一个方法。
(6)set()方法与setException()方法
继续看FutureTask类的代码,接下来看到的是set()方法与setException()方法,如下所示。
通过源码可以看出,set()方法与setException()方法整体逻辑几乎一样,只是在设置任务状态时一个将状态设置为NORMAL,一个将状态设置为EXCEPTIONAL。
至于finishCompletion()方法,前面已经分析过。
(7)run()方法与runAndReset()方法
接下来,就是run()方法了,run()方法的源代码如下所示。
可以这么说,只要使用了Future和FutureTask,就必然会调用run()方法来运行任务,掌握run()方法的流程是非常有必要的。在run()方法中,如果当前状态不是NEW,或者CAS操作返回的结果为false,则直接返回,不再执行后续逻辑,如下所示。
接下来,在try代码块中,将成员变量callable赋值给一个临时变量c,判断临时变量不等于null,并且任务状态为NEW,则调用Callable接口的call()方法,并接收结果数据。并将ran变量设置为true。当程序抛出异常时,将接收结果的变量设置为null,ran变量设置为false,并且调用setException()方法将任务的状态设置为EXCEPTIONA。接下来,如果ran变量为true,则调用set()方法,如下所示。
接下来,程序会进入finally代码块中,如下所示。
这里,将runner设置为null,如果任务的当前状态大于或者等于INTERRUPTING,也就是线程被中断了。则调用handlePossibleCancellationInterrupt()方法,接下来,看下handlePossibleCancellationInterrupt()方法的实现。
可以看到,handlePossibleCancellationInterrupt()方法的实现比较简单,当任务的状态为INTERRUPTING时,使用while()循环,条件为当前任务状态为INTERRUPTING,将当前线程占用的CPU资源释放,也就是说,当任务运行完成后,释放线程所占用的资源。
runAndReset()方法的逻辑与run()差不多,只是runAndReset()方法会在finally代码块中将任务状态重置为NEW。runAndReset()方法的源代码如下所示,就不重复说明了。
(8)removeWaiter()方法
removeWaiter()方法中主要是使用自旋循环的方式来移除WaitNode中的线程,比较简单,如下所示。
最后,在FutureTask类的最后,有如下代码。
关于这些代码的作用,会在后续深度解析CAS文章中详细说明,这里就不再探讨。
至此,关于Future接口和FutureTask类的源码就分析完了。
好了,今天就到这儿吧,我是冰河,我们下期见~~
Java并发编程常用的类和集合?
AtomicInteger
可以用原子方式更新int值。类AtomicBoolean、AtomicInteger、AtomicLong和AtomicReferencejava并发编程详解代码的实例各自提供对相应类型单个变量的访问和更新。java课程培训机构认为基本的原理都是使用CAS操作java并发编程详解代码:
booleancompareAndSet(expectedValue,updateValue);
如果此方法(在不同的类间参数类型也不同)当前保持expectedValuejava并发编程详解代码,则以原子方式将变量设置为updateValuejava并发编程详解代码,并在成功时报告true。
循环CAS,参考AtomicInteger中的实现:
publicfinalintgetAndIncrement(){ for(;;){ intcurrent=get(); intnext=current+1; if(compareAndSet(current,next)) returncurrent;
}
} publicfinalbooleancompareAndSet(intexpect,intupdate){ returnunsafe.compareAndSwapInt(this,valueOffset,expect,update);
}
ABA问题
因为CAS需要在操作值的时候检查下值有没有发生变化,如果没有发生变化则更新,但是如果一个值原来是A,变成java并发编程详解代码了B,又变成了A,那么使用CAS进行检查时会发现它的值没有发生变化,但是实际上却变化了。ABA问题的解决思路就是使用版本号。在变量前面追加上版本号,每次变量更新的时候把版本号加一,那么A-B-A就会变成1A-2B-3A。
从Java1.5开始JDK的atomic包里提供了一个类AtomicStampedReference来解决ABA问题。这个类的compareAndSet方法作用是首先检查当前引用是否等于预期引用,并且当前标志是否等于预期标志,如果全部相等,则以原子方式将该引用和该标志的值设置为给定的更新值。
ArrayBlockingQueue
一个由数组支持的有界阻塞队列。此队列按FIFO(先进先出)原则对元素进行排序。队列的头部是在队列中存在时间最长的元素。队列的尾部是在队列中存在时间最短的元素。新元素插入到队列的尾部,队列获取操作则是从队列头部开始获得元素。这是一个典型的“有界缓存区”,固定大小的数组在其中保持生产者插入的元素和使用者提取的元素。一旦创建了这样的缓存区,就不能再增加其容量。试图向已满队列中放入元素会导致操作受阻塞;试图从空队列中提取元素将导致类似阻塞。
此类支持对等待的生产者线程和使用者线程进行排序的可选公平策略。默认情况下,不保证是这种排序。然而,通过将公平性(fairness)设置为true而构造的队列允许按照FIFO顺序访问线程。公平性通常会降低吞吐量,但也减少了可变性和避免了“不平衡性”。
LinkedBlockingQueue
一个基于已链接节点的、范围任意的blockingqueue。此队列按FIFO(先进先出)排序元素。队列的头部是在队列中时间最长的元素。队列的尾部是在队列中时间最短的元素。新元素插入到队列的尾部,并且队列获取操作会获得位于队列头部的元素。链接队列的吞吐量通常要高于基于数组的队列,但是在大多数并发应用程序中,其可预知的性能要低。
可选的容量范围构造方法参数作为防止队列过度扩展的一种方法。如果未指定容量,则它等于Integer.MAX_VALUE。除非插入节点会使队列超出容量,否则每次插入后会动态地创建链接节点。
如果构造一个LinkedBlockingQueue对象,而没有指定其容量大小,LinkedBlockingQueue会默认一个类似无限大小的容量(Integer.MAX_VALUE),这样的话,如果生产者的速度一旦大于消费者的速度,也许还没有等到队列满阻塞产生,系统内存就有可能已被消耗殆尽了。
如何深入学习Java并发编程?
Java如何学?我java并发编程详解代码的经验告诉java并发编程详解代码你
之前就听说Java很难学java并发编程详解代码,自己亲身实践之后,感觉确实如此,想学好Java并非易事。以下三点是必须要做到的:1:课前认真预习;2:课上认真听讲;3:课后认真复习,勤练代码。只有做好这三点才能跟上老师的步伐。学习编程语言没有捷径可走,关键的一点就是坚持练习,只有每天保证一定的代码练习量,在遇到问题时才有一定的思路。
编程语言的学习是一个漫长的过程,欲速则不达,不能一步登天。在这个过程中需要慢慢积累经验,把基础打扎实。不要认为写出了一个简单的小程序,就觉得自己已经学的很好了,这只不过是编程学习过程中的一个小小实践。
学习Java,看书是必不可少的一项内容,但是我们在看书的时候,不要等到完全理解了才动手敲代码,而是应该在看书的同时敲代码,因为程序运行中的各种情况可以让java并发编程详解代码你更快更牢固地掌握知识点。虽然学习中不要求英语非常好,但不能一点不会,最起码像JavaAPI简单的文档还是要能看懂的,另外建议再开启一个“金山词霸”,方便翻译,单词看多了就会越来越熟练,在学Java的同时还可以提高英文水平。对于新手学习java有困难不知道怎么去做的可以加扣:五七八接着再来不要断开零二四后面跟着再来一四四连在一起,进行大神的交流同时得到帮助,获取免费听课权限!!!
程序代码是软件开发最重要的成果之一,其中渗透了程序员的思想与灵魂。当你学习一个类以后,你就可以自己写个简单的程序来运行一下,看看有什么结果,然后再多调用几个类的方法,看看运行结果,这样可以非常直观地学习类的使用方法,而且记忆非常深刻。学开发不应该满足把代码调通,而是应该尝试换个方式写行不行。
有人说学习编程就是个破坏的过程,把书本上的例子,自己学习Documentation编写的例子在运行通过以后,不断地尝试着用不同的方法实现,不断地尝试破坏代码的结构,看看会有什么结果。通过这样的方式,你会非常熟练地掌握Java。
在学习Java这段时间,有时候会觉得有点苦,但是我觉得正是有了奋斗时的苦,才能换来学成后的甜。当你认真写代码做完一个项目时,你会有一种成就感,心里会有一种说不出的喜悦。学Java靠的是韧劲,靠的是拼劲,靠的是坚持不懈。如果做好了这几点,我想学习Java对你来说不会太难。还有,你自己要有信心,相信自己能学会,要学会激励自己,加油!
经验总结:
1.做任何事情都要专注:你不专注,别人能做到90%-100%,你只能处在最底层。
2.代码保持规范性,细致了解代码机制;
3.确保计算机基础知识的扎实性,提升自己分析问题和解决问题的能力;
4.多做实习,多和老师做项目;
5.勤记笔记,勤敲代码,勤问问题,勤积累,多做总结;
6.要不断建立自己的人脉圈,构建一个属于自己的小圈子——IT圈。
java学习java并发编程是啥子意思?
一般来说,在java中实现高并发是基于多线程编程的,所谓并发,也就是多个线程同时工作,来处理java并发编程详解代码我们的业务,在机器普遍多核心的今天,并发编程的意义极为重大,因为java并发编程详解代码我们有多个cpu供线程使用,如果我们的应用依然只使用单线程模式来工作的话,是极度浪费机器资源的。而多线程并发编程就很好的解决了这个问题。
Java并发编程:核心理论?
并发编程是Java程序员最重要的技能之一,也是最难掌握的一种技能。它要求编程者对计算机最底层的运作原理有深刻的理解,同时要求编程者逻辑清晰、思维缜密,这样才能写出高效、安全、可靠的多线程并发程序。电脑培训发现本系列会从线程间协调的方式(wait、notify、notifyAll)、Synchronized及Volatile的本质入手,详细解释JDK为我们提供的每种并发工具和底层实现机制。在此基础上,我们会进一步分析java.util.concurrent包的工具类,包括其使用方式、实现源码及其背后的原理。本文是该系列的第一篇文章,是这系列中最核心的理论部分,之后的文章都会以此为基础来分析和解释。
关于java并发编程及实现原理,还可以查阅《Java并发编程:Synchronized及其实现原理》。
一、共享性
数据共享性是线程安全的主要原因之一。如果所有的数据只是在线程内有效,那就不存在线程安全性问题,这也是我们在编程的时候经常不需要考虑线程安全的主要原因之一。但是,在多线程编程中,数据共享是不可避免的。最典型的场景是数据库中的数据,为了保证数据的一致性,我们通常需要共享同一个数据库中数据,即使是在主从的情况下,访问的也同一份数据,主从只是为了访问的效率和数据安全,而对同一份数据做的副本。我们现在,通过一个简单的示例来演示多线程下共享数据导致的问题。
二、互斥性
资源互斥是指同时只允许一个访问者对其进行访问,具有唯一性和排它性。我们通常允许多个线程同时对数据进行读操作,但同一时间内只允许一个线程对数据进行写操作。所以我们通常将锁分为共享锁和排它锁,也叫做读锁和写锁。如果资源不具有互斥性,即使是共享资源,我们也不需要担心线程安全。例如,对于不可变的数据共享,所有线程都只能对其进行读操作,所以不用考虑线程安全问题。但是对共享数据的写操作,一般就需要保证互斥性,上述例子中就是因为没有保证互斥性才导致数据的修改产生问题。
关于java并发编程详解代码和java并发编程实战的介绍到此就结束了,不知道你从中找到你需要的信息了吗 ?如果你还想了解更多这方面的信息,记得收藏关注本站。