并发编程-线程安全

ゝ一纸荒年。 2022-04-23 18:36 285阅读 0赞

## 原因：**Java内存模型** ##

共享内存模型指的就是Java内存模型(简称JMM)，**JMM****决定一个线程对共享变量的写入时****,能****对另一个线程可见**。**线程之间的共享变量存储在主内存（****main memory****）中，每个线程都有一个私有的本地内存（****local memory****），本地内存中存储了该线程以读****/****写共享变量的副本**。

**当****多个线程同时访问一个数据的时候，可能本地内存没有及时刷新到主内存，所以就会发生线程****安全****问题。**

## 解决 方法:同步（让其他线程知道变量被修改） ##

### 多线程有三大特性 ###

原子性：多个操作 要么全部执行并且执行的过程不会被任何因素打断，要么就都不执行。

可见性：一个线程修改了这个变量的值，其他线程能够立即看得到修改的值。

有序性：程序执行的顺序按照代码的先后顺序执行。

### synchronized ###

private Object lock = new Object();
    
        /**
         * 修饰需要进行同步的方法，此时锁的对象为this
         */
        public synchronized void getId(){
            System.out.println("getId只允许一次被一个线程访问");
        }
    
        /**
         * 同步代码块，锁的粒度可以更细
         * 并且充当锁的对象不一定是this，也可以是其它对象，所以使用起来更加灵活
         */
        public void getName(){
            synchronized (lock){
                System.out.println("getName只允许一次被一个线程访问");
            }
        }

锁静态方法，是锁的.class 多个实例化公用一把锁。

### Lock锁 ###

需要在使用时手动获取锁和释放锁

Lock lock  = new ReentrantLock();
    lock.lock();
    try{
    //可能会出现线程安全的操作
    }finally{
    //一定在finally中释放锁
    //也不能把获取锁在try中进行，因为有可能在获取锁的时候抛出异常
      lock.ublock();
    }

## 死锁 ##

两个线程（多个），相互等待获取对方的锁。导致锁无法释放

## Threadlocal ##

每一个线程都可以独立地改变自己的副本，而不会影响其它线程所对应的副本

void set(Object value)设置当前线程的线程局部变量的值。

• public Object get()该方法返回当前线程所对应的线程局部变量。

• public void remove()将当前线程局部变量的值删除，目的是为了减少内存的占用，该方法是JDK 5.0新增的方法。当线程结束后，对应该线程的局部变量将自动被垃圾回收

• protected Object initialValue()返回该线程局部变量的初始值

（每一个线程里面，Threadlocal开始都为空，即便在开启这个线程之前已经赋值）

class Res {
    	// 生成序列号共享变量
    	public static Integer count = 0;
    	public static ThreadLocal<Integer> threadLocal = new ThreadLocal<Integer>() {
    		protected Integer initialValue() {
    
    			return 0;
    		};
    
    	};
    
    	public Integer getNum() {
    		int count = threadLocal.get() + 1;
    		threadLocal.set(count);
    		return count;
    	}
    }

### 重排序 ###

为了提高运行效率，编译器和处理器可能会对操作做重排序。

（就是有可能会把第一行代码，放在第三行执行，前提是没有数据依赖）

（单线程没不需要考虑这个问题）

(多线程下给公共变量加上Volatile)

数据依赖分三种：

![20190408182757406.png][]

### 锁的分类 ###

重入锁、读写锁

重入锁：（递归锁）同一线程 外层函数获得锁之后 ，内层递归函数仍然有获取该锁的代码，但不受影响。（ReentrantLock、synchronized）

读写锁：两个线程同时读一个资源没有任何问题，所以应该允许多个线程能在同时读取共享资源。但是如果有一个线程想去写这些共享资源，就不应该再有其它线程对该资源进行读或写（ReentrantReadWriteLock ）

static Map<String, Object> map = new HashMap<String, Object>();
    	static ReentrantReadWriteLock rwl = new ReentrantReadWriteLock();
    	static Lock r = rwl.readLock();
    	static Lock w = rwl.writeLock();
    
    	// 获取一个key对应的value
    	public static final Object get(String key) {
    		r.lock();
    		try {
    			System.out.println("正在做读的操作,key:" + key + " 开始");
    			Thread.sleep(100);
    			Object object = map.get(key);
    			System.out.println("正在做读的操作,key:" + key + " 结束");
    			System.out.println();
    			return object;
    		} catch (InterruptedException e) {
    
    		} finally {
    			r.unlock();
    		}
    		return key;
    	}
    
    	// 设置key对应的value，并返回旧有的value
    	public static final Object put(String key, Object value) {
    		w.lock();
    		try {
    
    			System.out.println("正在做写的操作,key:" + key + ",value:" + value + "开始.");
    			Thread.sleep(100);
    			Object object = map.put(key, value);
    			System.out.println("正在做写的操作,key:" + key + ",value:" + value + "结束.");
    			System.out.println();
    			return object;
    		} catch (InterruptedException e) {
    
    		} finally {
    			w.unlock();
    		}

悲观锁、乐观锁

乐观锁：不会上锁，但是在更新时会判断其他线程在这之前有没有对数据进行修改。有修改重试，直到修改成功。

悲观锁：加锁（读锁、写锁、行锁等），当其他线程想要访问数据时，都需要阻塞挂起。

CAS无锁模式

比较再交换，是一种乐观锁。

它包含三个参数CAS(V,E,N): V表示要更新的变量，E表示预期值，N表示新值。仅当V值等于E值时，才会将V的值设为N，如果V值和E值不同，则说明已经有其他线程做了更新，则当前线程什么都不做。最后，CAS返回当前V的真实值。

问题：在一段期间A曾经被改成B，然后又改回A，那CAS操作就会误认为它从来没有被修改过。（通过AtomicStampedReference控制变量版本保证CAS的正确性）

补充：

StringBuffer是线程安全的，每次操作字符串，String会生成一个新的对象，而StringBuffer不会；StringBuilder是非线程安全的

fail-fast：机制是java集合(Collection)中的一种错误机制。（在遍历的时候修改数据会报ConcurrentModificationException）

[20190408182757406.png]: /images/20220223/454444f714d54d19b38b3461599c8cd5.png