java并发编程笔记

1. java并发编程学习：如何等待多个线程执行完成

实现方式多种多样，下面列两种供参考：

importjava.util.ArrayList;
importjava.util.List;
importjava.util.concurrent.*;


publicclassMain{
publicstaticvoidmain(String[]args)throwsInterruptedException,ExecutionException{
System.out.println("方式1");
System.out.println("================================================");
//方式1
//创建一个线程池，并创建10个线程放入线程池执行
ExecutorServicepool=Executors.newCachedThreadPool();
for(inti=0;i<10;i++){
pool.execute(newMyThread("线程"+i));
}
//线程池不再接收新任务
pool.shutdown();
//线程池中的所有线程都执行完pool.isTerminated()才返回true
while(!pool.isTerminated()){
Thread.sleep(100);
}
System.out.println("所有线程执行完成");

System.out.println("

方式2");
System.out.println("================================================");

//方式2
ExecutorServicepool2=Executors.newCachedThreadPool();
List<Future>futures=newArrayList<>();
for(inti=0;i<10;i++){
//使用实现Callable接口的方式创建线程，通过Future可以获取线程中返回的结果
Futurefuture=pool2.submit(newMyThread2("线程"+i));
futures.add(future);
}

for(Futurefuture:futures){
//该方法会阻塞主线程，直到线程执行完成
future.get();
}
System.out.println("所有线程执行完成");
}

}

classMyThreadextendsThread{
privateStringname;

publicMyThread(Stringname){
this.name=name;
}

@Override
publicvoidrun(){
try{
Thread.sleep(3000);
}catch(InterruptedExceptione){
e.printStackTrace();
}
System.out.println(name+"执行完成");
}
}


{
privateStringname;

publicMyThread2(Stringname){
this.name=name;
}

@Override
publicObjectcall()throwsException{
try{
Thread.sleep(3000);
}catch(InterruptedExceptione){
e.printStackTrace();
}
System.out.println(name+"执行完成");
returnnull;
}
}

2. 《Java并发编程实战》pdf下载在线阅读，求百度网盘云资源

《Java并发编程实战》（Brian Goetz）电子书网盘下载免费在线阅读

链接：https://pan..com/s/1LkHQ1LOcgxHjCxplxfhmSg提取码：1234

书名：Java并发编程实战

作者：Brian Goetz

译者：童云兰

豆瓣评分：9.0

出版社：机械工业出版社华章公司

出版年份：2012-2

页数：293

内容简介：

本书深入浅出地介绍了Java线程和并发，是一本完美的Java并发参考手册。书中从并发性和线程安全性的基本概念出发，介绍了如何使用类库提供的基本并发构建块，用于避免并发危险、构造线程安全的类及验证线程安全的规则，如何将小的线程安全类组合成更大的线程安全类，如何利用线程来提高并发应用程序的吞吐量，如何识别可并行执行的任务，如何提高单线程子系统的响应性，如何确保并发程序执行预期任务，如何提高并发代码的性能和可伸缩性等内容，最后介绍了一些高级主题，如显式锁、原子变量、非阻塞算法以及如何开发自定义的同步工具类。

本书适合Java程序开发人员阅读。

作者简介：

本书作者都是Java Community Process JSR 166专家组（并发工具）的主要成员，并在其他很多JCP专家组里任职。Brian Goetz有20多年的软件咨询行业经验，并着有至少75篇关于Java开发的文章。Tim Peierls是“现代多处理器”的典范，他在BoxPop.biz、唱片艺术和戏剧表演方面也颇有研究。Joseph Bowbeer是一个Java ME专家，他对并发编程的兴趣始于Apollo计算机时代。David Holmes是《The Java Programming Language》一书的合着者，任职于Sun公司。Joshua Bloch是Google公司的首席Java架构师，《Effective Java》一书的作者，并参与着作了《Java Puzzlers》。Doug Lea是《Concurrent Programming》一书的作者，纽约州立大学 Oswego分校的计算机科学教授。

3. JAVA并发编程实践的内容简介

《JAVA并发编程实践》随着多核处理器的普及，使用并发成为构建高性能应用程序的关键。Java 5以及6在开发并发程序中取得了显着的进步，提高了Java虚拟机的性能以及并发类的可伸缩性，并加入了丰富的新并发构建块。在《JAVA并发编程实践》中，这些便利工具的创造者不仅解释了它们究竟如何工作、如何使用，还阐释了创造它们的原因，及其背后的设计模式。

4. java并发编程问题

import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
public class CachedFactorizer implements Servlet { //java 网络访问中的缓存编程
// @GuardedBy is an annotation introced by Brian Goetz in his excellent
// book on concurrency : Java Concurrency In Practice. The idea is that
// you indicate the lock that you need to hold before you access a particular
// member variable.
@GuardedBy("this") private BigInteger lastNumber;
//means you should synchronize on "this" before accessing lastNumber.
@GuardedBy("this") private BigInteger[] lastFactors;
//means you should synchronize on "this" before accessing lastFactors.
@GuardedBy("this") private long hits;
//means you should synchronize on "this" before accessing hits.
@GuardedBy("this") private long cacheHits;
//means you should synchronize on "this" before accessing cacheHits.
public synchronized long getHits() {
return hits;
}
public synchronized double getCacheHitRatio() {
return (double) cacheHits / (double) hits;
}

public void service(ServletRequest req, ServletResponse resp) {
BigInteger i = extractFromRequest(req);
BigInteger[] factors = null;
//访问前面提到的那些敏感数据之前，先call synchronized(this) 同步
synchronized(this) {
++hits; //hit 自动加1
if(i.equals(lastNumber)) { //如果i和lastNumber是相等的话
++cacheHits; //cacheHits 自动加1
factors = lastFactors.clone(); //factors更新数据用lastFactors
}
}
if(factors == null) { //如果factors是空的话。
factors = factor(i); //更新factors的数据
synchronized(this) { //访问前面提到的那些敏感数据之前，先call synchronized(this) 同步
lastNumber = i; //更新lastNumber
lastFactors = factors.clone(); //lastFactors 用factors来更新
}
}
encodeIntoResponse(resp, factors); //取得resp然后返回对应数据
}
}

5. java并发编程主要用来解决什么问题，应用场景是什么

解决性能问题.多个线程一起跑.可以使用多个cpu.
另外有时外部系统会成为瓶颈,多个并发,可以避免对于外部系统的等待.
所以基本上网络编程都是并发的. 大量数据需要处理的代码也往往会用并发来提速.

6. java并发编程中，有哪些同步和互斥机制

多线程共享资源，比如一个对象的内存，怎样保证多个线程不会同时访问（读取或写入）这个对象，这就是并发最大的难题，因此产生了 互斥机制（锁）。
using the same monitor lock.

获取锁后，该线程本地存储失效，临界区（就是获得锁后释放锁之前 的代码区）从主存获取数据,并在释放锁后刷入主存。
互斥：
保证临界区代码线程间互斥。
synchronized实现同步的基础：
java中每个对象都可以作为锁

一个任务可以多次获得锁，比如在一个线程中调用一个对象的 synchronized标记的方法，在这个方法中调用第二个synchronized标记的方法，然后在第二个synchronized方法中调用第三个synchronized方法。一个线程每次进入一个synchronized方法中JVM都会跟踪加锁的次数，每次+1，当该这个方法执行完毕,JVM计数-1；当JVM计数为0时，锁完全被释放,其他线程可以访问该变量。
在使用并发时将对象的field设为private 很重要！尤其是使用static变量（evil static variable） 使用 Lock lock =new ReentrantLock()的问题是代码不够优雅，增加代码量；我们一般都是使用synchronized实现互斥机制。但是1.当代码中抛出异常时，显示锁的finally里可以进行资源清理工作。2.ReentrantLock还给我们更细粒度的控制力

7. 什么是java并发性 深度剖析Java的并发性

做并发编程之前，必须首先理解什么是并发，什么是并行。

并发（concurrency）和并行（parallellism）关系：

解释一：并行是指两个或者多个事件在同一时刻发生；而并发是指两个或多个事件在同一时间间隔发生。

解释二：并行是在不同实体上的多个事件，并发是在同一实体上的多个事件。

解释三：在一台处理器上“同时”处理多个任务，在多台处理器上同时处理多个任务。如hadoop分布式集群

所以并发编程的目标是充分的利用处理器的每一个核，以达到最高的处理性能。

8. Java并发编程（二）为什么需要多线程

*使用线程可以把占据时间长的程序中的任务放到后台去处理
*程序的运行速度可能加快
*在一些等待的任务实现上如用户输入、文件读写和网络收发数据等，线程就比较有用了。在这种情况下可以释放一些珍贵的资源如内存占用等等。
*多线程技术在IOS软件开发中也有举足轻重的位置。

9. Java并发编程番外篇（一）如何结束一个线程

线程有四种状态，任何一个线程肯定处于这四种状态中的一种：1) 产生(New)：线程对象已经产生，但尚未被启动，所以无法执行。如通过new产生了一个线程对象后没对它调用start()函数之前。 2) 可执行(Runnable)：每个支持多线程的系统都有一个排程器，排程器会从线程池中选择一个线程并启动它。当一个线程处于可执行状态时，表示它可能正处于线程池中等待排排程器启动它;也可能它已正在执行。如执行了一个线程对象的start()方法后，线程就处于可执行状态，但显而易见的是此时线程不一定正在执行中。 3) 死亡(Dead)：当一个线程正常结束，它便处于死亡状态。如一个线程的run()函数执行完毕后线程就进入死亡状态。 4) 停滞(Blocked)：当一个线程处于停滞状态时，系统排程器就会忽略它，不对它进行排程。当处于停滞状态的线程重新回到可执行状态时，它有可能重新执行。如通过对一个线程调用wait()函数后，线程就进入停滞状态，只有当两次对该线程调用notify或notifyAll后它才能两次回到可执行状态。