⑴ android synchronized 与性能相关吗
这个synchronized其实是一个线程锁，在保持数据同步上起到很到作用。你现在的状况 我猜你只要记住就行了 你暂时不用接触这些 下面是关于synchronized的一些理解吧！ 一、当两个并发线程访问同一个对象object中的这个synchronized(this)同步代码块时，一个时间内只能有一个线程得到执行。另一个线程必须等待当前线程执行完这个代码块以后才能执行该代码块。 二、当一个线程访问object的一个synchronized(this)同步代码块时，其他线程对object中所有其它synchronized(this)同步代码块的访问将被阻塞。 三、然而，当一个线程访问object的一个synchronized(this)同步代码块时，另一个线程仍然可以访问该object中的除synchronized(this)同步代码块以外的部分。 四、第三个例子同样适用其它同步代码块。也就是说，当一个线程访问object的一个synchronized(this)同步代码块时，它就获得了这个object的对象锁。结果，其它线程对该object对象所有同步代码部分的访问都被暂时阻塞。 五、以上规则对其它对象锁同样适用 ========================i值的传输=============== 解析main函数的代码块 TT t1 = new TT(); Thread tt = new Thread(t1); tt.start(); t1.m2(); System.out.println("t1.i = "+t1.i); TT t1 = new TT();//很简单 初始化这个TT类。但这个TT是继承了Runnable接口的类。并且实现了Runnable的run方法。 Thread tt = new Thread(t1);//实例化一个线程实例。并将TT类的句柄传给这个线程。 tt.start();//启动线程，这个就是启动tt类中的run方法。但和直接运行run方法不一样。记住这点。start（）代表这个线程启动了。就开始运行线程里的方法 public void run(){ m1(); } 这个 然后这个方法去调用m1()方法。********* ================= int i = 100; public synchronized void m1(){ try{ i=200; Thread.sleep(5000); System.out.println("m1:i = "+i); }catch(InterruptedException ie){ ie.printStackTrace(); } 虽然int i = 100;但try里面给i赋值了。现在的i =200; Thread.sleep(5000);线程睡了5秒的觉 System.out.println("m1:i = "+i);//然后打印了i的值 。这个i等于200；所以打印出200； ============================= 再看 t1.m2();他是通过TT句柄方法m2()方法。这个你应该理解吧！ 运行m2()方法 ============================ public synchronized void m2() throws Exception{ i=300; Thread.sleep(2000); System.out.println("m2:i = "+i); } i=300;给i赋值，所以i等于300 Thread.sleep(2000);线程睡了2秒觉。 System.out.println("m2:i = "+i);醒来后打印了个300 =========================== 最后一句System.out.println("t1.i = "+t1.i); 这个地方就看t1.i（加好后面的，前面只是字符串），这个就是直接调用TT里的变量i 这个时候的i被修改了编程300了 所以是300.
⑵ 学习Android要懂什么技术
入门的话有以上知识储备就够了，如果要深的话，最好把java编程思想，java并发编程实战，深入理解jvm这几本书搞定，消化。最重要的是多练，不然一切都是白费。可以一边学一边做个小项目，这样成长会比较快一些
——————————————————————
补充：如果想去一些好的互联网公司的话，比如阿里，个人感觉手里有几个靠谱的项目，然后上面那几本书中的东西都能搞定，应该没有问题
⑶ android学习的问题（java相关）
html与xml是数据的表现形式，在网络上一般以http协议或tcp协议传输，所以“熟悉HTML/XML/HTTP”说白了就是要知道http协议。通信接口就是获取这些数据的服务端，这类似于网址，但他们返回的内容是使用xml或json表现的数据而非传统的html，所以你要会服务端编程，即servlet或其他j2ee技术；另外你还需要知道如何对数据进行封闭和解析。对于通信协议你可以看看<java网络编程》， 服务端的话一般大学学java的都会学到。多线程的话可以看看《java并发编程实战》。
⑷ android多核，多线程该如何用
在程序开发的实践当中，为了让程序表现得更加流畅，我们肯定会需要使用到多线程来提升程序的并发执行性能。但是编写多线程并发的代码一直以来都是一个相对棘手的问题，所以想要获得更佳的程序性能，我们非常有必要掌握多线程并发编程的基础技能。
众所周知，Android 程序的大多数代码操作都必须执行在主线程，例如系统事件(例如设备屏幕发生旋转)，输入事件(例如用户点击滑动等)，程序回调服务，UI 绘制以及闹钟事件等等。那么我们在上述事件或者方法中插入的代码也将执行在主线程。
一旦我们在主线程里面添加了操作复杂的代码，这些代码就很可能阻碍主线程去响应点击/滑动事件，阻碍主线程的 UI 绘制等等。我们知道，为了让屏幕的刷新帧率达到 60fps，我们需要确保 16ms 内完成单次刷新的操作。一旦我们在主线程里面执行的任务过于繁重就可能导致接收到刷新信号的时候因为资源被占用而无法完成这次刷新操作，这样就会产生掉帧的现象，刷新帧率自然也就跟着下降了(一旦刷新帧率降到 20fps 左右，用户就可以明显感知到卡顿不流畅了)。
为了避免上面提到的掉帧问题，我们需要使用多线程的技术方案，把那些操作复杂的任务移动到其他线程当中执行，这样就不容易阻塞主线程的操作，也就减小了出现掉帧的可能性。
那么问题来了，为主线程减轻负的多线程方案有哪些呢？这些方案分别适合在什么场景下使用？Android 系统为我们提供了若干组工具类来帮助解决这个问题。
AsyncTask: 为 UI 线程与工作线程之间进行快速的切换提供一种简单便捷的机制。适用于当下立即需要启动，但是异步执行的生命周期短暂的使用场景。
HandlerThread: 为某些回调方法或者等待某些任务的执行设置一个专属的线程，并提供线程任务的调度机制。
ThreadPool: 把任务分解成不同的单元，分发到各个不同的线程上，进行同时并发处理。
IntentService: 适合于执行由 UI 触发的后台 Service 任务，并可以把后台任务执行的情况通过一定的机制反馈给 UI。
了解这些系统提供的多线程工具类分别适合在什么场景下，可以帮助我们选择合适的解决方案，避免出现不可预期的麻烦。虽然使用多线程可以提高程序的并发量，但是我们需要特别注意因为引入多线程而可能伴随而来的内存问题。举个例子，在 Activity 内部定义的一个 AsyncTask，它属于一个内部类，该类本身和外面的 Activity 是有引用关系的，如果 Activity 要销毁的时候，AsyncTask 还仍然在运行，这会导致 Activity 没有办法完全释放，从而引发内存泄漏。所以说，多线程是提升程序性能的有效手段之一，但是使用多线程却需要十分谨慎小心，如果不了解背后的执行机制以及使用的注意事项，很可能引起严重的问题。
⑸ 接触Android网络编程需要什么知识基础
Android平台的网络应用绝大部分都是基于Java的编程接口的，也就是说我们开发类似的运用的时候可以有多种选择，比J2me确实好多了。
2.1. 标准Java接口
java.net.*下面提供了访问 HTTP 服务的基本功能。使用这部分接口的基本操作主要包括：
·创建 URL 以及 URLConnection / HttpURLConnection 对象
· 设置连接参数
·连接到服务器
· 向服务器写数据
·从服务器读取数据
import java.io.InputStream;
import java.io.OutputStream;
import java.net.URL;
import java.net.URLConnection;
import java.net.HttpURLConnection;
try {
// 创建一个 URL 对象
URL url = new URL(your_url);
// 创建一个 URL 连接，如果有代理的话可以指定一个代理。
URLConnection connection = url.openConnection(Proxy_yours);
// 对于 HTTP 连接可以直接转换成 HttpURLConnection，
// 这样就可以使用一些 HTTP 连接特定的方法，如 setRequestMethod() 等
//HttpURLConnection connection =
(HttpURLConnection)url.openConnection(Proxy_yours);
// 在开始和服务器连接之前，可能需要设置一些网络参数
connection.setConnectTimeout(10000);
connection.addRequestProperty("User-Agent",
"J2me/MIDP2.0");
// 连接到服务器
connection.connect();
// 往服务器写数据，数据会暂时被放到内存缓存区中
// 如果仅是一个简单的 HTTP GET，这一部分则可以省略
OutputStream outStream = connection.getOutputStream();
ObjectOutputStream objOutput = new ObjectOutputStream(outStream);
objOutput.writeObject(new String("this is a string..."));
objOutput.flush();
// 向服务器发送数据并获取应答
InputStream in = connection.getInputStream();
// 处理数据
...
} catch (Exception e) {
// 网络读写操作往往会产生一些异常，所以在具体编写网络应用时
// 最好捕捉每一个具体以采取相应措施
}
2.2. Apache接口
Apache HttpClient 是一个开源项目，弥补了 java.net.* 灵活性不足的缺点，为客户端的HTTP编程提供高效、最新、功能丰富的工具包支持。Android 平台引入了 Apache HttpClient 的同时还提供了对它的一些封装和扩展，例如设置缺省的HTTP超时和缓存大小等。早期的 Android 曾同时包括 Commons HttpClient （org.apache.commons.httpclient.*） 和 HttpComponents （org.apache.http.client.* ），不过当前版本 (1.5) 中开发者只能使用后者，也就是说类似以下的一些类：
使用这部分接口的基本操作与 java.net.* 基本类似，主要包括：
· 创建 HttpClient 以及 GetMethod / PostMethod， HttpRequest 等对象
·设置连接参数
·执行 HTTP 操作
· 处理服务器返回结果
import org.apache.http.HttpEntity;
import org.apache.http.HttpHost;
import org.apache.http.HttpResponse;
import org.apache.http.auth.AuthScope;
import org.apache.http.auth.UsernamePasswordCredentials;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.conn.params.ConnRoutePNames;
import org.apache.http.params. HttpConnectionParams;
import org.apache.http.client.params. HttpClientParams;
try {
// 创建 HttpParams 以用来设置 HTTP 参数（这一部分不是必需的）
HttpParams params = new BasicHttpParams();
// 设置连接超时和 Socket 超时，以及 Socket 缓存大小
HttpConnectionParams.setConnectionTimeout(params, 20 * 1000);
HttpConnectionParams.setSoTimeout(params, 20 * 1000);
HttpConnectionParams.setSocketBufferSize(params, 8192);
// 设置重定向，缺省为 true
HttpClientParams.setRedirecting(params, true);
// 设置 user agent
HttpProtocolParams.setUserAgent(params, userAgent);
// 创建一个 HttpClient 实例
// 注意 HttpClient httpClient = new HttpClient(); 是Commons HttpClient
// 中的用法，在 Android 1.5 中我们需要使用 Apache 的缺省实现 DefaultHttpClient
HttpClient httpClient = new DefaultHttpClient(params);
// 创建 HttpGet 方法，该方法会自动处理 URL 地址的重定向
HttpGet httpGet = new HttpGet ("http://www.test_test.com/");
HttpResponse response = client.execute(httpGet);
if (response.getStatusLine().getStatusCode() != HttpStatus.SC_OK) {
// 错误处理，例如可以在该请求正常结束前将其中断
httpGet.abort();
}
// 读取更多信息
Header[] headers = response.getHeaders();
HttpEntity entity = response.getEntity();
Header header = response.getFirstHeader("Content-Type");
} catch (Exception ee) {
//
} finally {
// 释放连接
client.getConnectionManager().shutdown();
}
import org.apache.http.HttpEntity;
import org.apache.http.HttpHost;
import org.apache.http.HttpResponse;
import org.apache.http.auth.AuthScope;
import org.apache.http.auth.UsernamePasswordCredentials;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.conn.params.ConnRoutePNames;
import org.apache.http.params. HttpConnectionParams;
import org.apache.http.client.params. HttpClientParams;
try {
// 创建 HttpParams 以用来设置 HTTP 参数（这一部分不是必需的）
HttpParams params = new BasicHttpParams();
// 设置连接超时和 Socket 超时，以及 Socket 缓存大小
HttpConnectionParams.setConnectionTimeout(params, 20 * 1000);
HttpConnectionParams.setSoTimeout(params, 20 * 1000);
HttpConnectionParams.setSocketBufferSize(params, 8192);
// 设置重定向，缺省为 true
HttpClientParams.setRedirecting(params, true);
// 设置 user agent
HttpProtocolParams.setUserAgent(params, userAgent);
// 创建一个 HttpClient 实例
// 注意 HttpClient httpClient = new HttpClient(); 是Commons HttpClient
// 中的用法，在 Android 1.5 中我们需要使用 Apache 的缺省实现 DefaultHttpClient
HttpClient httpClient = new DefaultHttpClient(params);
// 创建 HttpGet 方法，该方法会自动处理 URL 地址的重定向
HttpGet httpGet = new HttpGet ("http://www.test_test.com/");
HttpResponse response = client.execute(httpGet);
if (response.getStatusLine().getStatusCode() != HttpStatus.SC_OK) {
// 错误处理，例如可以在该请求正常结束前将其中断
httpGet.abort();
}
// 读取更多信息
Header[] headers = response.getHeaders();
HttpEntity entity = response.getEntity();
Header header = response.getFirstHeader("Content-Type");
} catch (Exception ee) {
//
} finally {
// 释放连接
client.getConnectionManager().shutdown();
}
以下例子以 HttpGet 方式通过代理访问 HTTPS 网站：
try {
HttpClient httpClient = new HttpClient();
// 设置认证的数据
httpClient.getCredentialsProvider().setCredentials(
new AuthScope("your_auth_host", 80, "your_realm"),
new UsernamePasswordCredentials("username", "password"));
// 设置服务器地址，端口，访问协议
HttpHost targetHost = new HttpHost("www.test_test.com", 443, "https");
// 设置代理
HttpHost proxy = new HttpHost("192.168.1.1", 80);
httpClient.getParams().setParameter
(ConnRoutePNames.DEFAULT_PROXY, proxy);
// 创建一个 HttpGet 实例
HttpGet httpGet = new HttpGet("/a/b/c");
// 连接服务器并获取应答数据
HttpResponse response = httpClient.execute(targetHost, httpGet);
// 读取应答数据
int statusCode = response.getStatusLine().getStatusCode();
Header[] headers = response.getHeaders();
HttpEntity entity = response.getEntity();
} catch (Exception ee) {
//
2.3. Android接口
android.net.* 实际上是通过对 Apache 的 HttpClient 的封装来实现的一个 HTTP 编程接口，同时还提供了 HTTP 请求队列管理， 以及 HTTP 连接池管理，以提高并发请求情况下（如转载网页时）的处理效率，除此之外还有网络状态监视等接口。
以下是一个通过 AndroidHttpClient 访问服务器的最简例子：
import import android.net.http.AndroidHttpClient;
try {
AndroidHttpClient client = AndroidHttpClient.newInstance(“your_user_agent”);
// 创建 HttpGet 方法，该方法会自动处理 URL 地址的重定向
HttpGet httpGet = new HttpGet ("http://www.test_test.com/");
HttpResponse response = client.execute(httpGet);
if (response.getStatusLine().getStatusCode() != HttpStatus.SC_OK) {
// 错误处理
}
// 关闭连接
client.close();
} catch (Exception ee) {
//
}
⑹ android 开4个线程 速度会提升4倍吗
对于Android平台上的线程优先级设置来说可以处理很多并发线程的阻塞问题，比如很多无关紧要的线程会占用大量的CPU时间，虽然通过了MultiThread来解决慢速I/O但是合理分配优先级对于并发编程来说十分重要。Android在线程方面主要使用的是Java本身的Thread类，我们可以在Thread或Runnable接口中的run方法首句加入 Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND); //设置线程优先级为后台，这样当多个线程并发后很多无关紧要的线程分配的CPU时间将会减少，有利于主线程的处理，相关的Thread优先级定义罗列有以下几种: int THREAD_PRIORITY_AUDIO //标准音乐播放使用的线程优先级 int THREAD_PRIORITY_BACKGROUND //标准后台程序 int THREAD_PRIORITY_DEFAULT // 默认应用的优先级 int THREAD_PRIORITY_DISPLAY //标准显示系统优先级，主要是改善UI的刷新 int THREAD_PRIORITY_FOREGROUND //标准前台线程优先级 int THREAD_PRIORITY_LESS_FAVORABLE //低于favorable int THREAD_PRIORITY_LOWEST //有效的线程最低的优先级 int THREAD_PRIORITY_MORE_FAVORABLE //高于favorable int THREAD_PRIORITY_URGENT_AUDIO //标准较重要音频播放优先级 int THREAD_PRIORITY_URGENT_DISPLAY //标准较重要显示优先级，对于输入事件同样适用。
⑺ Android新手有哪些资料比较好
必须的java基础的
一、java
（a）基本语法(如继承、异常、引用、泛型等)
Java核心技术 卷I（适合入门）
进阶
Effective Java中文版（如何写好的Java代码）
Java解惑 （介绍烂Java代码是什么样的）
（b）多线程、并发
Java并发编程实战 （系统全面的介绍了Java的并发，如何设计支持并发的数据结构）
（c）Java 7
Java程序员修炼之道 （详细的介绍Java 7 的新特性）
（d）Java 8
写给大忙人看的Java SE 8
函数式编程思维
（e）Java虚拟机
深入理解Java虚拟机 （并不是那么难，Java程序员都该看看）
（f）性能优化
Java性能优化权威指南 （后面的章节好像用处不大，前面有些部分还是值得看）
二、算法与数据结构
算法时间复杂度、空间复杂度的基本认知
熟悉常用数据结构：链表、队列、散列表、树等；
递归、分支等基本思想；
常用算法应用：排序、查找、比较等
数据结构与算法分析 （涵盖面比较全、示例是Java语言）
算法设计与分析基础 （实用主义的典型、偏算法设计）
编程珠玑 （实践型算法数据）
三、操作系统
对linux/OS的基本认知
Linux的常用命令
鸟哥的Linux私房菜
Linux内核设计与实现(原书第3版) （很精炼的语言描述清楚了内核算法）
四、网络
Http/Https
TCP/IP
图解HTTP
图解TCP/IP
进阶
TCP/IP详解
五、Android
四大组件（服务、广播、ContentProvider、页面容器）
基础UI组件（ListView、ViewPager）
异步任务机制（AsyncTask、Handler、线程池）
布局优化（层级、绘制、碎片化处理）
图片加载（Bitmap、缓冲区）
UniversalMusicePlayer (通过学习一个音乐播放器的代码能很快了解四大组件)
Android Training官方课程
Android一些重要知识点解析整理
Android UI/UX库（各类常用组件及扩展组件的集合）
Picasso 、 Glide （两个图片加载库）
The Google I/O 2015 Android App (Google大会官方的App，适合学习各类实现)
Android开发技术前线 （定期翻译、发布国内外Android优质的技术、开源库、软件架构设计、测试等文章）
进阶
第三方库集合 （列举了常见的各方向第三方库）
⑻ 以后希望从事android方向,java多线程重要吗
Java多线程面试问题
1.进程和线程之间有什么不同？
一个进程是一个独立(self contained)的运行环境，它可以被看作一个程序或者一个应用。而线程是在进程中执行的一个任务。Java运行环境是一个包含了不同的类和程序的单一进程。线程可以被称为轻量级进程。线程需要较少的资源来创建和驻留在进程中，并且可以共享进程中的资源。
2. 多线程编程的好处是什么？
在多线程程序中，多个线程被并发的执行以提高程序的效率，CPU不会因为某个线程需要等待资源而进入空闲状态。多个线程共享堆内存(heap memory)，因此创建多个线程去执行一些任务会比创建多个进程更好。举个例子，Servlets比CGI更好，是因为Servlets支持多线程而CGI不支持。
3. 用户线程和守护线程有什么区别？
当我们在Java程序中创建一个线程，它就被称为用户线程。一个守护线程是在后台执行并且不会阻止JVM终止的线程。当没有用户线程在运行的时候，JVM关闭程序并且退出。一个守护线程创建的子线程依然是守护线程。
4. 我们如何创建一个线程？
⑼ 随笔之如何判断Android应用进程是否为单线程及闲扯多核并行编程
我最早接触多核知识是2008年末到2009年初。背景很简单，我是做高性能网络数据传输服务器的，类似FTPServer一样。服务器的吞吐能力最好是随着CPU核数的增加成倍增长.。根据多核并行的知识，这是最理想的情况（有一个公式，可以计算性能和CPU核数的关系），但应用内部各个线程并非完全独立。即线程是独立运行在不同CPU核上，但是线程中所干的事情却在逻辑上有关系。例如运行在线程A上的函数等待运行在线程B上另外一个函数的执行结果。这样就导致性能不是随CPU核数线性增长。
根据上面的介绍，对于多核并行编程来说，最最重要的事情就是将你的应用中那些混淆不清的逻辑关系能拆成互不干扰或者互相牵连较少的模块，并让他们在不同线程上运行。这样就真正发挥多核的优势了。
1 对于纯逻辑关系的问题，也就是非计算方面（即矩阵计算，编解码等），要想能掰叱清楚。难度很大。七大姑，八大姨的，能分那么清楚吗？目前，这方面的资料较少。
2 对于纯计算方面的问题，例如矩阵计算，要研究的就不是编码，而是数学，要把计算拆成各个小块，每个小块可单独运行在独立线程上，然后再汇总计算结果。这方面资料较多，如周伟明的《多核计算与程序设计》。编程角度看，OpenMP是一个多核并行计算的好库。（有人能尝试下用OpenMP来拆分逻辑工作吗？）
好了。多核的故事闲扯到这，对于纯逻辑关系问题，再扯的话就会扯到线程池，并发编程，异步IO，惊群效应，分布式内存管理等等等等。
下面来看如何判断Android应用进程为单线程还是多线程？请先思考，再看下面的答案：1android应用是运行在android环境中的，简单来说，是运行在dalvik虚拟机之上，而dalvik虚拟机本身是会创建一些线程，例如垃圾回收线程，JDWP调试线程2Android应用会经常利用binder和系统服务进行IPC通信，根据binder本身的特性，它会动态创建线程来完成外界请求。
以上两类线程都是应用不可控的，保守估计，这类不可控线程至少在3个左右3除了主线程之外的，就是应用自己是否会创建线程了。
查看一个进程中线程的方法有：
ps，加一些参数（具体忘记了），可看某个进程下的线程及线程号，但无法区别是系统创建的线程还是应用自己创建的线程
kill -3 对应进程pid，这个方法会向进程发送SIGQUIT消息，dalvik虚拟机会跟踪这个信号，并打印该进程所有线程的堆栈到一个文件
native代码（如Jni库）如果直接调用posix创建线程，则上述方法无法跟踪（如果该线程能回调到Java层，也可以获取信息），只能根据ps得到的信息，减去SIGQUIT得到的信息来判断了。不过这类线程一般都是应用自己创建的。
⑽ java并发编程从入门到精通怎么样
还是不错的
目录
第一部分：线程并发基础
第1章概念部分 1
1.1CPU核心数、线程数(主流cpu，线程数的大体情况说一下) 1
1.2CPU时间片轮转机制2
1.3什么是进程和什么是线程4
1.4进程和线程的比较5
1.5什么是并行运行 7
1.6什么是多并发运行 8
1.7什么是吞吐量 9
1.8 多并发编程的意义及其好处和注意事项 10
1.9 分布式与并发运算关系 11
1.10Linux和Window多并发可以采取不的一样机制(apache和tomcat？？) 6
第2章认识Java里面的Thread 12
2.1线程的实现三种方法 (先感受一下创建几个多线程方法实例演练)12
2.2Thread里面的属性和方法(通过工具看看能不能监控到thread里面的一些属性值)16
2.3线程的生命周期19
2.4什么是守护线程31
2.5线程组33
2.6当前线程副本ThreadLocal(用意和实际应用场景) 35
2.7线程异常的处理(单个和组)38
第3章 Thread安全 39
3.0 线程的内存模型
3.1 什么是不安全(写个代码例子多并发带来的一些问题，变量互串，相互影响) 39
3.2 什么是安全(写个代码例子，安全的三种(多实例,加锁,线程安全的集合类)情况，引出锁) 43
3.3第一种锁：隐式锁，又称线程同步synchronized(举几个例子实际演示一下，及其写法注意，带来的额外开销)45
3.4第二种锁：显示锁，Lock；及其与synchronized的区别(ReentrantReadWriteLock)49
3.5 什么是死锁 53
3.6看如下代码的锁有用吗 55
3.7关键字：volatile 57
3.8原子操作：atomic(atomic包FutureTask, AtomicLong等) 59
3.9 线程同步和锁的原理(有待弄清楚锁的运行机制和原理) 61
3.10 单利模式的写法 63
第4章 线程安全的集合类 64
4.1 java.util.concurrent. ConcurrentMap 64
4.2 java.util.concurrent.ConcurrentHashMap 66
4.3 java.util.concurrent. CopyOnWriteArrayList 68
4.4 java.util.concurrent. CopyOnWriteArraySet 70
4.5 非concurrent下面的线程安全集合类(Hashtable 和 Vector 和StringBuffer) 72
4.6 集合类安全的实现原理剖析 75
第二部分：线程并发晋级之高级部分 75
第5章 多线程之间交互：线程阀
(一句话解释什么叫阀门，最好都能讲到实际使用的例子)75
5.1 线程安全的阻塞队列BlockingQueue (详解一翻java.util.concurrent.ConcurrentLinkedDeque 和java.util.concurrent. ConcurrentLinkedQueue) 76
5.2 同步计数器CountDownLatch 81
5.3循环障碍CyclicBarrier 84
5.4信号装置Semaphore87
5.5任务机制FutureTask 90
第6章 线程池 115
6.1 什么是线程池 90
6.2 newFixedThreadPool的使用 92
6.3newCachedThreadPool 的使用 94
6.4newSingleThreadExecutor的使用(插图，原理)96
6.5线程池的好处(未使用的时候的情况，使用后的情况) 98
6.4认识ExecutorService(ThreadFactory先创建一个线程及其参数的详细讲解，如何自定义线程池)100
6.5线程池的原理 106
6.6 线程池在工作中的错误使用 112
第7章 JDK7新增的Fork/Join 115
7.1 什么是Fork/Join 架构 115
7.2 创建实际使用Fork/Join 线程池118
7.3合并任务的结果 123
7.4工作原理126
7.5异步运行任务 130
7.6在任务中抛出异常135
7.7结束任务 140
7.8 实际应用场景 143
第三部分：实际的使用与监控与拓展
第8章 线程，线程池在Servlet中 150
第9章 Tomcat中线程池如何设置 180
第10章 线程的监控及其日常工作中如何分析 210
linux分析监控方法
java的bin下面监控工具的使用
第11章 线程在Android开发中的体现 250
android的线程讲解