并发，即一个代码块同时被多个线程执行，代码块中的变量会被同时的线程修改成不同的值，造成数据错乱，运行结果错误现象产生，如何来避免这一问题产生呢？这就产生了锁机制，通过对代码块加锁，来保证同一时刻只能有一个线程来操作数据，这样就能保证数据的一致性。
一、锁机制
- 重入锁/不可重入锁
- 共享锁/互斥锁
- 乐观锁/悲观锁
- 自旋锁
重入锁/不可重入锁
在同一个线程中，可重复进入的锁，就可重入锁。如，一个线程中进入了一个带锁的方法，再次进入使用同一个锁的其他方法时，不需要再获取锁，可直接进入。
可重入锁
- ReentrantLock
- synchronized
不可重入锁
- NoReentrantLock
共享锁/互斥锁
当一个线程获取到锁后，其他线程也可以获取此锁，则此锁是共享锁，如读锁；如果其他线程不能获取此锁，则此锁是互斥锁，如写锁
- ReentrantReadWriteLock
乐观锁/悲观锁
乐观锁认为并发操作一定会修改数据；悲观锁认为并发操作不会修改数据，但在写数据时一般
乐观锁
- AtomickInteger
- AtomickXXX
悲观锁
- ReentrantLock
- synchronized
自旋锁
一般情况下线程在未获取到锁的情况下会被阻塞，而自旋锁则是内部有一个循环体在轮询锁是否可用。自旋锁可以减少线程上下文切换带来的消耗，但会消耗CPU。
- AtomicInteger
- AtomicXXXX
二、死锁
线程都要获取锁才能进行运行，但所有的线程都获取不到，导致出现所有线程都不能运行的情况，这种情况就叫作死锁。
死锁场景
1. 设计不当
线程内有多个锁，一个线程在获取锁A后，需要再次获取锁B才能执行相关代码，而此刻另一线程已经获取到锁B，但它却在等待获取锁A来执行代码，两个线程都要获取对方已经获取到的锁，而又都获取不到，造成死循环，也就是死锁现象。
2. 程序异常
线程在获取锁后执行相关代码，执行完相关代码后释放锁。但执行过程发生了异常，导致线程意外退出，获取到的锁没有被释放，导致其他所有线程都无法获取锁的情况。
解决方案：添加try/catch，在finally块里释放锁
class AClass{
ReentrantLock lock=new ReentrantLock();
void aMethod() {
lock.lock();
try {
doSomeThing();
} catch(Throwable e){
e.printStacktrace();
} finally {
lock.unlock();
}
}
}
三、synchronized使用方式
synchronized可根据加锁范围分为以下两种方式，但
- 锁对象
- 锁类
锁对象
即针对对象中的方法进行加锁，一个对象的加锁方法被线程进入后，其他线程不能再进入此对象加锁的方法，但可以进入不同对象的同一加锁方法。
- synchronized修饰普通方法
public synchronized void test1(){
...
}
- synchronized代码块，内部使用this或成员变量
public void test1(){
synchronized(this){
...
}
}
锁类
类锁与对象锁是一致的，但类方法在内存中只有一份。加锁的是整个类方法，当一个线程获取到类方法锁后，其他线程不能再进入此方法。
- synchronized修饰静态方法
public synchronized static void test1(){
....
}
- synchronized代码块，内部使用class
public void test1(){
synchronized(Test.class){
...
}
}
四、锁机制单例中的应用
单例对并发方面的考虑主要是
- 防止创建多个对象。单例要求全局只有一个对象
- 防止单例对象中的数据被并发修改造成错误
创建方式
1. 懒汉模式
需要时再创建
class ConnectionManager{
private static ConnectionManager sInstance = new ConnectionManager();
private ConnectionManager(){
}
/**
* 此方式每次获取都会加锁，目的是防止创建多个对象，
* 但创建对象只有一次，其他都是获取，造成性能损耗
*/
public synchronized static ConnectionManager getInstance(){
if(sInstance==null){
sInstance=new ConnectionManager();
}
return sInstance;
}
}
2. 饿汉模式
直接初始化（太饥饿，上来就直接吃）
public class ConnectionManager{
private static ConnectionManager sInstance = new ConnectionManager();
private ConnectionManager(){
}
public static ConnectionManager getInstance(){
return sInstance;
}
}
3. 双重检测
a. 为什么要2次null判断？
防止两个线程同时进入第一个if模块，当一个线程获取锁后创建一个对象；在它释放锁后，另一个线程获取到锁，又创建一个对象。
b. 为什么使用volatile修饰？
防止指令重排问题。sInstance=new ConnectionManager();这句代码并不是原子操作，它有三条指令：分配内存、初始化内存、赋值变量。如果先赋值后初始化，就可能会出现另一线程在第一个null判断时，发现不为空，直接使用对象的情况，而此时对象可能还没被初始化造成错误。
class ConnectionManager{
private volatile static ConnectionManager sInstance = null;
private ConnectionManager(){
}
public static ConnectionManager getInstance(){
if(sInstance==null){
synchronized(ConnectionManager.class){
if(sInstance==null){
sInstance=new ConnectionManager();
}
}
}
return sInstance;
}
}
4. 静态内部类
class ConnectionManager{
private ConnectionManager(){
}
public static ConnectionManager getInstance(){
return Holder.INSTANCE;
}
private static class Holder{
private final static ConnectionManager INSTANCE = new ConnectionManager();
}
}
5. 枚举
enum ConnectionManager{
INSTANCE;
private ConnectionManager(){
}
}
五、进程通信
- binder
- 管道
- 广播
- 文件
- socket
生产者消费者机制
信息号机制
六、线程安全相关类
容器类
- ConcurentHashMap
- CopyOnWriteArrayList
- CopyOnWriteArraySet
- LinkedBlockingList
- LinkedBlockingQueue
- Vector
- HashTable
- Collections.synchronizedList(new ArrayList<T>());
- Collections.synchronizedSet(new HashSet<T>());
- Collections.synchronizedMap(new HashMap<String,String>());
字符串类
- StringBuffer
