成功需要努力

本片文章以Java多线程简单实力为主，全部的例子选自java 编程思想第四版，全部都是自己手动对书 编写，如有疑问请直接留言。import java.util.ArrayList;import java.util.concurrent.Callable;import java.util.concurrent.ExecutionException;import java.util.conc

import java.util.concurrent.TimeUnit;/** * InnerThread1 创建了一个扩展自Thread 的匿名内部类， * 并且在构造器中创建了一个内部类的一个实例。如果内部类 * 具有你在其他方法中需要访问的特殊能力（新方法），那这么 * 做将会很有意义。但是，在大多数时候，创建线程的原因只是为 * 了使用Thread的能力，因此不必要创建匿名

/** * * join()方法解释： * 一个线程可以在其他线程之上调用Join()方法，其效果是等待一段时间直到第二个线程结束才继续执行。 * 如果某个线程在另一个线程t上调用t.join()，此线程将被挂起，直到目标线程t结束才恢复 * （即t.isAlive()返回为假）。 * 也可以在调用join()时带上一个超时参数（单位可以是毫秒，或者毫秒和纳秒）， * 这样如果目标线程

import java.util.concurrent.ExecutorService;import java.util.concurrent.Executors;/** * 线程抛出异常实例。try catch是无法捕获异常的。 * * @create @author Henry @date 2016-11-23 * */public class ExceptionRun e

volatile关键字还确保了应用中的可视性。如果你将一个域声明为volatile的，那么只要对这个域产生了写操作，那么所有的读操作就都可以看到这个修改。即便使用了本地缓存，情况也确实如此，volatile域会立即被写入到主存中，而读取操作就发生在主存中。    理解原子性和易变性是不同的概念这一点很重要。在非volatile域上的原子操作不必刷新到主存中去，因此其他读取该域的任务也不必看

/** * 说明: 其中一个任务产生偶数，而其他任务消费这些数字。 * 这里，消费者任务的唯一工作就是检查偶数的有效性。 * * @create @author Henry @date 2016-11-24 * *//** * 首先，我们定义EvenChecker，即消费者任务，因为它将在随后所有的 * 示例中被复用。为了将EvenChecker与我们要试验的各种类型的生成器

import java.util.Timer;import java.util.TimerTask;import java.util.concurrent.ExecutorService;import java.util.concurrent.Executors;import java.util.concurrent.atomic.AtomicInteger;/** * Java SE

import java.util.ArrayList;import java.util.Collections;import java.util.List;import java.util.concurrent.ExecutorService;import java.util.concurrent.Executors;import java.util.concurrent.TimeUni

/** * 在其他对象上同步 * * DualSync.f()(通过同步整个方法)在this同步，而g()有一个在syncObject上同步 * 的synchronized块。因此，这两个同步是互相独立的。 * * @create @author Henry @date 2016-12-06 */class DualSynch { private Object syncOb

import java.util.ArrayList;import java.util.List;import java.util.Random;import java.util.concurrent.ExecutorService;import java.util.concurrent.Executors;import java.util.concurrent.TimeUnit;/

import java.io.IOException;import java.io.InputStream;import java.sql.Date;import java.util.concurrent.ExecutorService;import java.util.concurrent.Executors;import java.util.concurrent.Future;im

使用notify()而不是notifyAll()是一种优化。使用notify()时，在众多等待同一个锁的任务中只有一个会被唤醒，因此如果你希望使用notify()，就必须保证被唤醒的是恰当的任务。另外，为了使用notify()，所有任务必须等待相同的条件，因为如果你有多个任务在等待不同的条件，那么你就不会知道是否唤醒了恰当的任务。如果使用notify()，当条件发生变化时，必须只有一个任务能够从中

import java.util.concurrent.ExecutorService;import java.util.concurrent.Executors;import java.util.concurrent.TimeUnit;/** * 生产者和消费者 * * 请考虑这样一个饭店，它有一个厨师和一个服务员。这个服务员必须等待厨师准备好膳食。当厨师准备好时，他会通知服务员

wait()和notifyAll()方法以一种非常低级的方式解决了任务互操作问题，即每次交互时都握手。在许多情况下，你可以瞄向更高的抽象级别，使用同步队列来解决任务协作问题，同步队列在任何时刻都只允许一个任务插入或移除元素。在java.util.concurrent.BlockingQueue接口中提供了这个队列，这个接口有大量的标准实现。你通常可以使用LinkedBlockingQueue，它是

通过输入/输出在线程间进行通信通常很有用。提供线程功能的类库以“管道”的形式对线程的输入/输出提供了支持。它们在Java输入/输出类库中的对应物就是PipedWriter类（允许任务向管道写）和PipedReader类（允许不同任务从同一个管道中读取）。这个模型可以看成是“生产者-消费者”问题的变体，这里的管道就是一个封装好的解决方案。管道基本上是一个阻塞队列，存在于多个引入BlockingQue

现在你理解了，一个对象可以有synchronized方法或其他形式的加锁机制来防止别的任务在互斥还没有释放的时候就访问这个对象。你已经学习过，任务可以变成阻塞状态，所以就可能出现两种情况：某个惹我怒在等待另一个任务，而后者又等待别的任务，这样一直下去，直到这个链条上的任务又在等待第一个任务释放锁。这得到了一个任务之间相互等待的连续循环，没有哪个线程恩给你继续。这被称之为  死锁 。    如果

import java.util.Random;import java.util.concurrent.CountDownLatch;import java.util.concurrent.ExecutorService;import java.util.concurrent.Executors;import java.util.concurrent.TimeUnit;/** * Co

先介绍一下JDK内容：java.util.concurrent 类 CyclicBarrierjava.lang.Object 继承者 java.util.concurrent.CyclicBarrier--------------------------------------------------------------------------------public c

import java.util.ArrayList;import java.util.List;import java.util.Queue;import java.util.Random;import java.util.concurrent.ExecutorService;import java.util.concurrent.Executors;import java.util

import java.util.ArrayList;import java.util.List;import java.util.Random;import java.util.concurrent.DelayQueue;import java.util.concurrent.Delayed;import java.util.concurrent.ExecutorService;im