JUC探索笔记之一

什么是进程/线程？

进程是资源分配的最小单位，线程是程序运行的最小单位。进程是程序执行时间总和 = CPU加载上下文+CPU执行+CPU保存上下文 (上下文是除了cpu之外的运行环境)。 线程是共享了进程的上下文环境，的更为细小的CPU时间段，正是因为线程共享进程的数据，使用相同的地址空间，CPU切换线程远远快于切换进程。
例子 进程：word.exe 线程：纠错功能，断电恢复

并发的小例子

简单来说，并发就是多个线程争抢同一资源。并行是两个独立事件同时运行。一般需要应付并发难题的对象都是高内聚低耦合的资源类 （高度集成封装功能，不依赖于别人，同时暴露出接口供外界使用）。可以类比成 几个遥控器（线程）共同遥控一个空调（资源类）。若每个线程中对全局变量、静态变量只有读操作，而无写操作，一般来说，这个全局变量是线程安全的；若有多个线程同时执行写操作，一般都需要考虑线程同步，否则的话就可能影响线程安全。让我们来看一个经典的例子，三个窗口卖票。

public class SaleTicket {

	public static void main(String[] args) {
		Ticket ticket = new Ticket();	
		new Thread(() -> {for(int i = 0; i <= 40; i++) ticket.sale();},"A").start();
		new Thread(() -> {for(int i = 0; i <= 40; i++) ticket.sale();},"B").start();
		new Thread(() -> {for(int i = 0; i <= 40; i++) ticket.sale();},"C").start();		
	}
}

class Ticket {
	private int number = 0;
	public void sale() {
		if(number < 30) {
			System.out.println(Thread.currentThread().getName() + "卖出第" + (number++) + "还剩"+ (30 - number));
		}
	
	}
}

可以看到，上面通过Lambda表达式创建的三个线程同时在ticket类上进行读写操作（读了number后++），出现了问题。可以看到图片第一行和最后一行都是还剩24。

改进方法就是加锁，这里我们先不去深究lock，到后面会讲到

class Ticket {
	private int number = 0;
	Lock lock = new ReentrantLock();
	public void sale() {	
		lock.lock();
		try {
			if(number < 30) {
				System.out.println(Thread.currentThread().getName() + "卖出第" + (number++) + "还剩"+ (30 - number));
			}
		}catch(Exception e) {
			
		}finally {
			lock.unlock();
		}
	}
	
}

线程不安全的几个常见类

ArrayList, HashSet, HashMap都是比较常见的不安全的类，比如下面对ArrayList的测试就会出现不正常的现象

public static void listNotSafe() {
				List<String> list = new ArrayList<>();
				//List<String> list = Collections.synchronizedList(new ArrayList<>());
//				List<String> list = new CopyOnWriteArrayList<>();
				for(int i = 0; i < 10; i++) {
					new Thread(() -> {
						list.add(UUID.randomUUID().toString().substring(0, 8));
						System.out.println(list);
					} , String.valueOf(i)).start(); 
				}

				list.forEach(System.out::println);
			
	}

报了java.util.ConcurrentModificationException错误
Java提供了一些线程安全的类，比如java.util.concurrent下面的CopyOnWriteArrayList（用vector也可保证 数据一致性，但是效率低）
我们来看下这个类的写入函数是怎么回事，比如set方法如下

public E set(int index, E element) {
        final ReentrantLock lock = this.lock;
        lock.lock();
        try {
            Object[] elements = getArray();
            E oldValue = get(elements, index);

            if (oldValue != element) {
                int len = elements.length;
                Object[] newElements = Arrays.copyOf(elements, len);
                newElements[index] = element;
                setArray(newElements);
            } else {
                // Not quite a no-op; ensures volatile write semantics
                setArray(elements);
            }
            return oldValue;
        } finally {
            lock.unlock();
        }
    }

CopyOnWriteArrayList是CopyOnWrite 容器，CopyOnWrite 容器就是写时复制容器，在向一个容器添加元素的时候，不直接向当前容器Object[]添加， 而是将Object[]进行复制，复制出来的newElement, 然后向容器中添加新元素，然后将原容器的引用指向新容器setArry(newElements)。这样做的好处就是对copyOnWrite容器进行并发的读而不需要加锁，这是一种读写分离的思想。
同理 HashMap 用 java.util.concurrent.ConcurrentHashMap代替， HashSet用java.util.concurrent.CopyOnWriteArraySet
这些类为什么线程不安全会在后面讲到。