并发

作者: zlb | 来源:发表于2016-10-24 22:25 被阅读16次

Java并发教程
JAVA并发编程与高并发解决方案 - 并发编程二之线程安全
JAVA并发编程与高并发解决方案 - 并发编程三之线程安全
JAVA并发编程与高并发解决方案 - 并发编程四之 J.U.
JAVA并发编程与高并发解决方案 - 并发编程六之线程池
JAVA并发编程与高并发解决方案 - 并发编程五之 J.U.
服务器并发设计
数据库并发控制——悲观锁、乐观锁、MVCC
Java并发编程：并发容器
中并发控制（数据库）

并发:当有多个线程在操作时,如果系统只有一个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>
这样才不会有奇数出现

Java并发教程
Java并发教程 Java并发概述Java并发环境设置Java并发主要操作Java并发性线程间通信Java并发同步...
JAVA并发编程与高并发解决方案 - 并发编程二之线程安全
JAVA并发编程与高并发解决方案 - 并发编程二相关文章 JAVA并发编程与高并发解决方案 - 并发编程一 ...
JAVA并发编程与高并发解决方案 - 并发编程三之线程安全
JAVA并发编程与高并发解决方案 - 并发编程三相关文章 JAVA并发编程与高并发解决方案 - 并发编程一 ...
JAVA并发编程与高并发解决方案 - 并发编程四之 J.U.
JAVA并发编程与高并发解决方案 - 并发编程四相关文章 JAVA并发编程与高并发解决方案 - 并发编程一 ...
JAVA并发编程与高并发解决方案 - 并发编程六之线程池
JAVA并发编程与高并发解决方案 - 并发编程六相关文章 JAVA并发编程与高并发解决方案 - 并发编程一 ...
JAVA并发编程与高并发解决方案 - 并发编程五之 J.U.
JAVA并发编程与高并发解决方案 - 并发编程五相关文章 JAVA并发编程与高并发解决方案 - 并发编程一 ...
服务器并发设计
并发与并行并发技术选型结构并发状态并发集群和负载均衡并发（Coccurrency）和并行（Paralle...
数据库并发控制——悲观锁、乐观锁、MVCC
三种并发控制：悲观并发控制、乐观并发控制、多版本并发控制。悲观并发控制（又名“悲观锁”，Pessimistic ...
Java并发编程：并发容器
Java并发编程：并发容器之CopyOnWriteArrayList（转载） Java并发编程：并发容器之Conc...
中并发控制（数据库）
什么叫中等并发？不是高并发，不是低并发并发度说明举?典型方案高并发短时间内的大量并发冲突秒杀活动redis缓存 ...