并发编程实战学习1

基础篇

这篇对应归纳《Java并发编程实战》基础知识部分，主要是对一些概念的理解。

一,实现并发的优势：

1，实现计算机资源的充分利用，尤其是发挥多处理器的性能（例如，由于cpu的调度是基于线程，当在双核cpu中执行单线程任务是，即意味着只有一个cpu在工作，另一个cpu处于空闲状态。）

2，实现将不同任务分离开，在不同的线程中执行（比如，可将网页获取放在单独的线程，页面渲染放在单独的线程）

3，更灵敏的界面响应（可以想象，如果当我们的界面响应，还有处理都在一个线程中，那么当我们在做计算时，我们将不能响应用户的界面操作，用户点击界面，没有任何响应，体验会有多差可想而知。）

二,当然并发也会带来一些新的问题：

1，并发也意味着需要处理数据竞争，当多个线程竞争同一数据时，如果处理不当，可能会让程序出现意想不到的结果。

2，程序活跃性问题，单线程程序中只有在无限循环会造成程序执行不下去，而多线程中死锁，饥饿，活锁都会使程序出现问题。

3，性能问题，线程创建，线程切换，挂起也会带来一定的开销，所以多线程并发也不一定意味着更好的执行效率，还得平衡多线程带来的效率提高，还有线程开销。

三,线程安全

线程安全：多个线程访问同一个对象时，这个对象始终能表现出正确行为，那么就称这个对象对应的类是线程安全的。

当一个对象需要被多个线程共享，他就需要是线程安全的，实现变量线程安全，需要用到同步机制，Java中同步机制主要有synchronize（独占的加锁方式），volatile类型变量，显示锁（Lock）。

四,原子性

某个操作不可分割，（原子性指事务的一个完整操作。操作成功则提交，失败则回滚，即一件事要做就做完整，要么就什么都不做--来自百度）。

五,竞态条件

由于不恰当的执行时序而出现不正确的结果，即为竞态条件。（即程序运行出正确结果必须依赖于程序的执行顺序）书中例子：

A，B相约于星巴克见面，然而发现有两家星巴克，于是当A去了星巴克1，B去了星巴克2，极端情况下，A在星巴克1等不到B，5分钟后去星巴克2找B，而B也在5分钟后去星巴克1找A，这样循环下去，A将永远也将见不到B。

最常见的竞态条件是“先检查后执行”,下面程序咋一看，好像没什么问题，管理一个单例对象，但在多线程下，但A，B两个线程同时执行到判断时，都认为obj 是null，于是都创建一个Object对象，造成的结果是创建了两个Object对象。

class SingleConstance{
    private Object obj;
    public Object getInstance(){
        if(obj == null){
            obj = new Object();
        }
        return obj;
    }
}

六，Java内置锁

java中，每个对象都可以用于实现同步的锁，这些锁被称为内置锁（进入同步块时会获取锁，退出同步块时会释放锁）。

Java内置锁为互斥锁，意味着最多只有一个线程可以持有锁。

重入，内置锁是可重入锁，某个线程试图请求获取一个已经由它持有的锁，这个请求会成功。

public class ReentrantTest {

	private int state;
	
	//通过内置锁保护
	public synchronized int increment() {
		return ++state;
	}
	//通过内置锁保护
	public synchronized int mul(int param) {
		//执行increment时再此获取已经持有的锁
		return increment() * param;
	}
	public static void main(String arg[]) {
		ReentrantTest reentrantTest = new ReentrantTest();
		//执行mul时获取reentrantTest对象的锁
		reentrantTest.mul(3);
	}
}

七，对象共享

可见性，我们无法确保线程读取内存中变量是可以看到其他线程对该变量的修改，如下图，线程A对变量a的修改保存在自己的本地内存，如果没有即时同步到公共内存里，线程B是读取不到线程A对变量a的修改。

非原子性64位操作，非volatile类型的64位数值变量（double，long），JVM允许将64位的读操作或写操作分解为两个32为操作。当一个线程刚写入32位，而另一个线程去除该变量时，就会获取到一个无效的数据，所以在多线程中共享long，double必须使用同步或用volatile声明他们。

锁的可见性，加锁不仅局限于互斥性，还包括内存可见性。（A线程执行被锁保护的同步块后，当A释放锁之后，同步块中更新的变量对其他线程立即可见）

Volatile变量，弱同步机制，用来确保变量更新后立即对其他线程可见。（线程A写入一个volatile变量后，线程B随后去读该变量，在写入volatile变量之前对A可见的所有变量的值，在B对取volatile变量后，对B也可见）

发布与逸出

发布，使对象能够在当前作用域之外的代码中使用，例如将对象引用保存到其他地方。

逸出，不应该发布的对象被发布时，称为逸出，（如对象构造完成前就发布对象，就会破坏线程安全）。

class UnsafeStates{
    private String[] states = new String[]{"AK","AL"};
    public String[] getStates(){
        return states;
    }
}

1,以上方式发布对象其实就已经逸出了，任何调用者都可以修改该变量，你无法知道其他线程会对states做什么修改，所以states的状态已经不受UnsafeStates的掌控。

2,this引用逸出,this逸出需满足两个条件1,个是在构造函数中创建内部类;2,是在构造函数中就把这个内部类给发布了出去(以上观点来源与网上另一篇博客)，下面为一个this逸出例子，执行以下程序，你会发现打印出name为null，因为，OutClass还没被初始化完毕，引用就已经通过内部类对象逸出了。

import java.util.ArrayList;
import java.util.List;

import javax.xml.bind.helpers.ValidationEventImpl;

public class OutClass {
	private String name;
	
	public OutClass(List<InnerClass> classList) {
		classList.add(new InnerClass());
		try {
			Thread.currentThread().sleep(1000);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		name = "hello world";
	}
	
	public class InnerClass{
		public void onEvent() {
			System.out.println(OutClass.this.name);
		}
	}
	
	public static void main(String []arg) {
		List<InnerClass> innerClasses = new ArrayList<>();
		new Thread() {
			@Override
			public void run() {
				OutClass outClass = new OutClass(innerClasses);
			}
		}.start();
		
		new Thread() {
			@Override
			public void run() {
				for(int i=0;i<innerClasses.size();i++) {
					innerClasses.get(i).onEvent();
				}
			}
		}.start();
	}
}

线程封闭

访问共享可变数据时，通常需要同步，数据不共享，仅在线程内部访问即不需要同步，此技术称为线程封闭。

1，Ad-hoc线程封闭，简单的说就是你写程序的时候定义的共享对象，你自己控制，只在一个线程中使用它。（脆弱，尽可能不使用）

2，栈封闭，通过局部变量才能访问对象，我的理解是将共享的对象拷贝一份在当前线程，当前线程只操作这一份拷贝，不操作共享对象。如下无论哪个线程执行以下方法，都将拷贝一份Animal集合，保存到animals中。

public int loadTheArk(Collection<Animal> candidates){
    ShortedSet<Animal> animals;
    int numPairs = 0;
    Animal candidate = null;
    animals = new TreeSet<Animal>(new SpeciesGenderComparator());
    animals.addAll(candidates);
    for(Animal a : animals){
        if(candidate == null || !candidate.isPotentialMate(a))
            candidate = a;
        else{
            ark.load(new AnimalPair(candidate,a))
            ++ numPairs;
            candidate = null;
        }
    }
    return numPairs;
}

​

3，ThreadLocal类，本质上就是用来管理线程中的局部变量。

只提供四个方法 get(),set(),initialValue(),remove(),以下例子打印出来的hashCode是不一样的，说明不同线程通过同一个

threadLocal获取到的是本线程set进去的局部对象。

public class ThreadLocalTest {
	
	public static void main(String arg[]) {
		ThreadLocal<ThreadLocalTest> threadLocal = new ThreadLocal<>();
		Thread thread1 = new CusThread(threadLocal);
		Thread thread2 = new CusThread(threadLocal);
		thread1.start();
		thread2.start();
	}
	
	static class CusThread extends Thread{
		ThreadLocal<ThreadLocalTest> threadLocal;
		
		public CusThread(ThreadLocal<ThreadLocalTest> threadLocal) {
			this.threadLocal = threadLocal;
		} 

		@Override
		public void run() {
			ThreadLocalTest localTest = new ThreadLocalTest();
			threadLocal.set(localTest);
			System.out.println(threadLocal.get().hashCode());
		}
		
	}
}

不变性，满足线程安全的另一种方法是使用不可变对象。（可变对象在多线程间共享需要同步，然而如果对象不可变就是线程安全的）

不可变对象需满足以下条件

1，对象创建后其状态不可变。2，对象的所有域都是final。3，对象需正确创建（对象创建时没this逸出）如下就是线程安全的

public final class ThreeStooges[
    private final Set<String> stooges = new HashSet<String>();

    public ThreeStooges(){
        stooges.add("More");
        stooges.add("Larry");
    }
    
    public boolean isStooge(String name){
        return stooges.contains(name);
    }
}