并发

并发:当有多个线程在操作时,如果系统只有一个CPU,则它根本不可能真正同时进行一个以上的线程，它只能把CPU运行时间划分成若干个时间段,再将时间段分配给各个线程执行，在一个时间段的线程代码运行时，其它线程处于挂起状。.这种方式我们称之为并发(Concurrent)。
并行：当系统有一个以上CPU时,则线程的操作有可能非并发。当一个CPU执行一个线程时，另一个CPU可以执行另一个线程，两个线程互不抢占CPU资源，可以同时进行，这种方式我们称之为并行(Parallel)。
区别：并发和并行是即相似又有区别的两个概念，并行是指两个或者多个事件在同一时刻发生；而并发是指两个或多个事件在同一时间间隔内发生。在多道程序环境下，并发性是指在一段时间内宏观上有多个程序在同时运行，但在单处理机系统中，每一时刻却仅能有一道程序执行，故微观上这些程序只能是分时地交替执行。倘若在计算机系统中有多个处理机，则这些可以并发执行的程序便可被分配到多个处理机上，实现并行执行，即利用每个处理机来处理一个可并发执行的程序，这样，多个程序便可以同时执行

基本的线程机制

1.定义任务
<code>import java.util.concurrent.TimeUnit;
public class Liffoff implements Runnable{
protected int countDown = 10;
private int taskCount = 0;
private int id = taskCount ++;
public Liffoff(){}
public Liffoff(int countDown){
this.countDown = countDown;
}
public String status(){
return "#" + id + "(" + (countDown > 0 ? countDown : "Liffoff") + ")\t";
}
@Override
public void run() {
while(countDown -- > 0){
System.out.print(status());
//Thread.yield(); //线程调度器
try {
//Thread.sleep(1000);
TimeUnit.MILLISECONDS.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println();
}
public static void main(String[] args) {
Liffoff lif = new Liffoff();
lif.run();
}
}
</code>
在run()中对静态方法通常Thread.yield()的调用是对线程调度器(Java线程机制的一部分，可以将一个CPU从一个线程转移给另外一个线程)的一种建议

2.Thead 类
将Runnable对象转变为工作任务的传统方式是把它提交给一个Thread构造器

<code>public class BasicThread {
public static void main(String[] args) {
Thread t = new Thread(new Liffoff());
t.start();
System.out.println("waiting for Liffoff()");
}
}
</code>
Thread构造器只需要一个Runnable对象。调用Thread对象的start()方法为该线程执行必须的初始化操作，然后调用Runnable的run()方法以便在这个新线程中启动该任务。

3.使用Executor
Java SE5的java.util.concurrent包中的执行器(Executor)将为你管理Thread对象，从而简化了并发编程。Executor在客户端和执行之间提供了一个间接层

<code>import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class CachedThreadPool {
public static void main(String[] args) {
//ExecutorService exec = Executors.newCachedThreadPool();
//ExecutorService exec = Executors.newFixedThreadPool(5);
ExecutorService exec = Executors.newSingleThreadExecutor();
for(int i=0;i<3;i++){
exec.execute(new Liffoff());
}
exec.shutdown();
}
}
</code>

CachedThreadPool:在程序执行过程中通常会创建于所需数量相同的线程，然后在它回收旧线程时停止创建新的线程，因此它是合理的Executor的首选
FixedThreadPool:可以一次性预先执行代价高昂的线程分配，因而也就是限制线程的数量，这可以节省时间
SingleThreadExecutor：就像是线程数量为一的FixedThreadPool，如果向SingleThreadExecutor提交了多个任务，那么这个任务将会排队

4.从任务中产生返回值
<code>import java.util.concurrent.Callable;
public class TaskWithResult implements Callable<String>{
int id;
public TaskWithResult(int id){
this.id = id;
}
@Override
public String call() throws Exception {
return "result " + id;
}
}
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
public class CallableDemo {
public static void main(String[] args) {
ExecutorService exec = Executors.newCachedThreadPool();
List<Future<String>> str = new ArrayList<Future<String>>();
for(int i=0;i<10;i++){
str.add(exec.submit(new TaskWithResult(i)));
}
for(Future<String> s : str){
try {
System.out.println(s.get()+"\t");
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}
}
}
}

</code>

5.休眠
影响任务行为的一种简单方法是调用sleep()，这将使任务终止执行给定的时间，对sleep()的调用会抛出InterruptedException异常，并且你可以看到，它在run()中被捕获，因为异常不能跨线程传播会Main,所以你必须在本地处理所有在任务内部产生的异常：

6.优先级
线程的优先级将该线程的重要性传递给了调度器。尽管CPU处理现有线程集的顺序是不确定的但是调度器更倾向于让优先级高的先执行。
JDK共有10个优先级

<code>package priority;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class SimplePriority implements Runnable {
int countDown = 5;
volatile double d;
int priority;
public SimplePriority(int priority) {
this.priority = priority;
}
public String toString() {
return Thread.currentThread() + ":" + countDown;
}
@Override
public void run() {
Thread.currentThread().setPriority(priority);
while (true) {
for (int i = 0; i < 100000; i++) {
d += (Math.PI + Math.E) / (double) i;
if (i % 1000 == 0) {
Thread.yield();
}
System.out.println(this);
if (--countDown == 0)
return;
}
}
}
public static void main(String[] args) {
ExecutorService exe = Executors.newCachedThreadPool();
for (int i = 0; i < 3; i++) {
exe.execute(new SimplePriority(Thread.MAX_PRIORITY));
}
exe.execute(new SimplePriority(Thread.MAX_PRIORITY));
exe.shutdown();
}

}
</code>

7.让步

<code>
Thread.yield()
</code>

8.后台线程
后台线程是指程序运行的时候在后台提供一种通用服务的线程，并且这种线程并不属于程序中不可或缺的部分。因此当所有的后天线程结束时，程序也就终止了

<code>
package daemon;
import java.util.concurrent.TimeUnit;
public class SimpleDaemons implements Runnable{
@Override
public void run() {
while(true){
try {
TimeUnit.MILLISECONDS.sleep(1500);
System.out.println("current thread " + this);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
public static void main(String[] args) throws Exception{
for(int i=0;i<10;i++){
Thread daemon = new Thread(new SimpleDaemons());
daemon.setDaemon(true);
daemon.start();
}
TimeUnit.MILLISECONDS.sleep(1500);
}

}
</code>

9.捕获异常
由于线程的本质特性，使得你不能捕获线程中逃逸的异常，一旦线程掏出任务的run()方法，他就会想外传播到控制台，除非你采取特殊的步骤捕获这种错误的异常

<code>package ThreadException;
public class ExceptionThread2 implements Runnable{
@Override
public void run() {
Thread t = Thread.currentThread();
System.out.println("run by t" + t);
System.out.println("en :"+ t.getUncaughtExceptionHandler());
throw new RuntimeException();
}
}
package ThreadException;
import java.util.concurrent.ThreadFactory;
public class HandleThreadFactory implements ThreadFactory{
@Override
public Thread newThread(Runnable r) {
System.out.println("create new thread "+this);
Thread t = new Thread(r);
System.out.println("create t "+t);
t.setUncaughtExceptionHandler(new MyUncaughtExceptionHandler());
System.out.println("en " + t.getUncaughtExceptionHandler());
return t;
}
}
package ThreadException;
public class MyUncaughtExceptionHandler implements Thread.UncaughtExceptionHandler{
@Override
public void uncaughtException(Thread t, Throwable e) {
System.out.println("catch : "+e);
}
}
package ThreadException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class Exception {
public static void main(String[] args) {
ExecutorService exe = Executors.newCachedThreadPool(new HandleThreadFactory());
exe.execute(new ExceptionThread2());
}
}
</code>

共享受限资源

1.不正确的访问资源

<code>
package ShareResource;
public abstract class IntGenerator {
private volatile boolean canceled = false;
public abstract int next();
public void cancle(){ canceled = true;}
public boolean isCanceled(){return canceled;}
}
package ShareResource;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class EventGenerator extends IntGenerator{
private int currentEventValue = 0;
@Override
public int next() {
++currentEventValue;//递增过程任务可能被线程机制挂起，因此递增不是原子性操作
//Thread.yield();
++currentEventValue;
return currentEventValue;
}
public static void main(String[] args) {
EvenCheck.test(new EventGenerator());
}
}
package ShareResource;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class EvenCheck implements Runnable{
private IntGenerator generator;
private final int id;
public EvenCheck(IntGenerator generator,int id){
this.id = id;
this.generator = generator;
}
@Override
public void run() {
while(!generator.isCanceled()){
int val = generator.next();
if((val % 2) != 0){
System.out.println(val + "is not even");
generator.cancle();
}
}
}
public static void test(IntGenerator generator,int count){
ExecutorService exe = Executors.newCachedThreadPool();
for(int i=0;i < count;i++){
exe.execute(new EvenCheck(generator, i));
}
exe.shutdown();
}
public static void test(IntGenerator generator){
test(generator,10 );
}
}
</code>

输出结果：

从输出结果可知，产生了奇数，一个任务有可能在另一个任务执行第一个currentEventValue的递增操作之后，但是没有执行第二个操作之前，调用了next()方法，这就是线程冲突，多个线程共享一个变量

2.解决共享资源竞争
java以提供关键字synchronized的形式，为防止资源冲突提供内置支持，当任务要执行synchronized关键字保护的代码片段时，他将检查锁是否可用，然后回去锁，执行代码，释放锁。当在对象上调用其任意synchronized方法的时候，此对象都被加锁，这时该对象上的其他synchronized方法只有等到前一个方法调用完毕并释放锁之后才能被调用

<code>@Override
public synchronized int next() { //同步锁
//lock.lock();
++currentEventValue;//递增过程任务可能被线程机制挂起，因此递增不是原子性操作
++currentEventValue;
return currentEventValue;
}
</code>
这样才不会有奇数出现

最后编辑于：2017.12.04 06:20:33

人面猴
序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
沈念sama阅读 204,921评论 6赞 478
死咒
序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
沈念sama阅读 87,635评论 2赞 381
救了他两次的神仙让他今天三更去死
文/潘晓璐我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
开封第一讲书人阅读 151,393评论 0赞 338
道士缉凶录：失踪的卖姜人
文/不坏的土叔我叫张陵，是天一观的道长。经常有香客问我，道长，这世上最难降的妖魔是什么？我笑而不...
开封第一讲书人阅读 54,836评论 1赞 277
港岛之恋（遗憾婚礼）
正文为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
茶点故事阅读 63,833评论 5赞 368
恶毒庶女顶嫁案：这布局不是一般人想出来的
文/花漫我一把揭开白布。她就那样静静地躺着，像睡着了一般。火红的嫁衣衬着肌肤如雪。梳的纹丝不乱的头发上，一...
开封第一讲书人阅读 48,685评论 1赞 281
城市分裂传说
那天，我揣着相机与录音，去河边找鬼。笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。我是一名探鬼主播，决...
沈念sama阅读 38,043评论 3赞 399
双鸳鸯连环套：你想象不到人心有多黑
文/苍兰香墨我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
开封第一讲书人阅读 36,694评论 0赞 258
万荣杀人案实录
序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
沈念sama阅读 42,671评论 1赞 300
护林员之死
正文独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋以下内容为张勋视角年9月15日...
茶点故事阅读 35,670评论 2赞 321
白月光启示录
正文我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
茶点故事阅读 37,779评论 1赞 332
活死人
序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
沈念sama阅读 33,424评论 4赞 321
日本核电站爆炸内幕
正文年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
茶点故事阅读 39,027评论 3赞 307
男人毒药：我在死后第九天来索命
文/蒙蒙一、第九天我趴在偏房一处隐蔽的房顶上张望。院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
开封第一讲书人阅读 29,984评论 0赞 19
一桩弑父案，背后竟有这般阴谋
文/苍兰香墨我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。一阵脚步声响...
开封第一讲书人阅读 31,214评论 1赞 260
情欲美人皮
我被黑心中介骗来泰国打工，没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。一个月前我还...
沈念sama阅读 45,108评论 2赞 351
代替公主和亲
正文我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
茶点故事阅读 42,517评论 2赞 343

并发

基本的线程机制

共享受限资源

推荐阅读更多精彩内容