线程安全

线程安全

学习材料来源于网络
如有侵权，联系删除

竞态条件与临界区

public class Demo {
    public inti= 0;
    public void incr(){
        i++;
    }
}

多个线程访问了相同的资源，向这些资源做了写操作时，对执行顺序有要求。
临界区: incr方法内部就是临界区域，关键部分代码的多线程并发执行，会对执行结果产生影响。
竞态条件:可能发生在临界区域内的特殊条件。多线程执行incr方法中的i++关键代码时，产生了竞态条件。

共享资源

• 如果一段代码是线程安全的,则它不包含竞态条件。只有当多个线程更新共享资源时,才会发生竞态条件。
• 栈封闭时，不会在线程之间共享的变量，都是线程安全的。
• 局部对象引用本身不共享，但是引用的对象存储在共享堆中。如果方法内创建的对象，只是在方法中传递，并且不对其他线程可用，那么也是线程安全的。

判定规则:如果创建、使用和处理资源，永远不会逃脱单个线程的控制，该资源的使用是线程安全的。

不可变对象

创建不可变的共享对象来保证对象在线程间共享时不会被修改，从而实现线程安全。

实例被创建，value变量就不能再被修改，这就是不可变性。

public class Demo{
    private int value = 0;
    public Demo(int value){
        this.value = value;
	}
	public int getValue(){
   		return this.value;
	}
}

java字节码反编译：javap -p -v "文件"

原子操作定义

原子操作可以是一个步骤，也可以是多个操作步骤，但是其顺序不可以被打乱，也不可以被切割而只执行其中的一部分(不可中断性)。

将整个操作视作一个整体是原子性的核心特征。

public class Demo{
    public inti= 0;
    public void incr(){
        i++;
    }
}

三个步骤：

1. 加载i
2. 计算+1
3. 赋值

存在竞态条件，线程不安全，需要转变为原子操作才能安全。方式:循环CAS、锁上例只是针对一个变量的原子操作改进，我们也可以实现更大逻辑的原子操作。

示例1

public class LockDemo2 {
    int i = 0;

    public void add() {
        synchronized (this) {
            i++;
        }
    }

    public static void main(String[] args) throws InterruptedException {
        LockDemo2 ld = new LockDemo2();

        for (int i = 0; i < 2; i++) {
            new Thread(() -> {
                for (int j = 0; j < 10000; j++) {
                    ld.add();
                }
            }).start();
        }
        Thread.sleep(2000L);
        System.out.println(ld.i);
    }
}

示例2

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class LockDemo3 {
    volatile int i = 0;

  private   Lock lock = new LingFengLock();

    public void add() {
        lock.lock();
        try {
            // TODO  很多业务操作
            i++;
        }finally {
            lock.unlock();
        }
    }

    public static void main(String[] args) throws InterruptedException {
        LockDemo3 ld = new LockDemo3();

        for (int i = 0; i < 20; i++) {
            new Thread(() -> {
                for (int j = 0; j < 10000; j++) {
                    ld.add();
                }
            }).start();
        }
        Thread.sleep(2000L);
        System.out.println(ld.i);
    }
}