1.什么是多线程同步
当多个线程同时共享同一个全局变量或者静态变量，做写操作时，可能会存在数据冲突的问题，也就是线程安全的问题。如果是读操作是不会发生数据冲突问题的。在《公路遇袭》故事中，没有明显有数据冲突的情节，但是在现实中却非常常见，比如春节抢票，假如从北京到上海就1辆车，1万张票，买票的人有10万，如果依次执行，第一个登陆进去的人看到余票1万，就买了，后面的人看到的余票只有9999张，然后顺序购买。假如一万个人同时在时刻0.0登陆，然后0.2秒后同时将票抢走，而在0.1秒的时候又有1万个人抢票，此时看到的余票仍然是1万张，然后在0.3s的时候下单，但是此时却没有票了，这时候系统就出现线程安全问题了。
我们现在模拟一下上述情况，并研究一下如何改进。首先我们假定有100张火车票，2个窗口同时抢票。
很容易写出如下代码：
class ThreadTrain implements Runnable {
private int count = 100;
@Override
public void run() {
while (count > 0) {
try {
Thread.sleep(50);
} catch (InterruptedException e) {
e.printStackTrace();
}
sale();
}
}
public void sale() {
System.out.println(Thread.currentThread().getName() + ",出售第" + (100 - count + 1) + "票");
count--;
}
}
public class ThreadDemo {
public static void main(String[] args) {
ThreadTrain threadTrain = new ThreadTrain();
Thread t1 = new Thread(threadTrain);
Thread t2 = new Thread(threadTrain);
t1.start();
t2.start();
}
}
但是此时打印结果是这样的：
Thread-1,出售第1票
Thread-0,出售第1票
Thread-0,出售第3票
Thread-1,出售第3票
Thread-0,出售第5票
Thread-1,出售第5票
Thread-0,出售第7票
Thread-1,出售第7票
Thread-0,出售第9票
Thread-1,出售第9票
········
Thread-0,出售第96票
Thread-1,出售第97票
Thread-0,出售第98票
Thread-1,出售第99票
Thread-0,出售第100票
Thread-1,出售第101票
很明显两个窗口将每个票都买了一遍，这就意味着同一个座位对应两张票，而且最后竟然还多卖了一张，这是不行的。
多卖了是因为剩下最后一张的时候，前一个线程判断count>0后正在睡眠期间后一个线程进来了，此时前者还没有卖出后者就继续执行了。对于上面的代码，我们首先想到卖出的时候先判断一下count是否大于0.
public void sale() {
if (count > 0) {
System.out.println(Thread.currentThread().getName() + ",出售第" + (100 - count + 1) + "票");
count--;
}
}
执行来看，最后没有多卖出，就避免了上面遇到的问题，但是仍然存在重复卖票的情况。如何解决呢？多线程之间使用同步synochronized或者使用锁lock。
2.多线程的三大特征
上面我们通过一个例子说明了什么是多线程同步，如何通过严谨的计算机语言来描述呢？
多线程程序具备三大特征：原子性，可见性和有序性。
什么是原子性
即一个操作或者多个操作 要么全部执行并且执行的过程不会被任何因素打断，要么就都不执行。
一个很经典的例子就是银行账户转账问题：
比如从账户A向账户B转1000元，那么必然包括2个操作：从账户A减去1000元，往账户B加上1000元。这2个操作必须要具备原子性才能保证不出现一些意外的问题。
我们操作数据也是如此，比如i = i+1；其中就包括，读取i的值，计算i，写入i。这行代码在Java中是不具备原子性的，则多线程运行肯定会出问题，所以也需要我们使用同步和lock这些东西来确保这个特性了。
原子性其实就是保证数据一致、线程安全一部分，
什么是可见性
当多个线程访问同一个变量时，一个线程修改了这个变量的值，其他线程能够立即看得到修改的值。
若两个线程在不同的cpu，那么线程1改变了i的值还没刷新到主存，线程2又使用了i，那么这个i值肯定还是之前的，线程1对变量的修改线程没看到这就是可见性问题。
什么是有序性
程序执行的顺序按照代码的先后顺序执行。
一般来说处理器为了提高程序运行效率，可能会对输入代码进行优化，它不保证程序中各个语句的执行先后顺序同代码中的顺序一致，但是它会保证程序最终执行结果和代码顺序执行的结果是一致的。如下：
int a = 10; //语句1
int r = 2; //语句2
a = a + 3; //语句3
r = a*a; //语句4
则因为重排序，他还可能执行顺序为 2-1-3-4，1-3-2-4
但绝不可能 2-1-4-3，因为这打破了依赖关系。
显然重排序对单线程运行是不会有任何问题，而多线程就不一定了，所以我们在多线程编程时就得考虑这个问题了。
3.synochronized解决访问冲突
synochronized可以对某个代码块包起来，也可以将某个函数加上synochronized来修饰，前者称为同步代码块，后者称为同步函数。
使用同步函数解决访问冲突问题的方法是将可能发生冲突的代码用synochronized包起来，结构如下
synchronized (同一个数据){
可能发生线程冲突问题的代码
}
这里的同一个数据是什么呢？可以是任意对象，我测试过，使用静态变量可以，使用System.getenv()可以，在sale里定义一个局部变量也可以，使用Integer a=1;也可以，总之是个对象就可以。不过为了防止费解，我们还是使用全局变量或者静态变量比较好一些。所以我们完整的代码如下所示：
class ThreadTrain implements Runnable {
private int count = 100;
private static Object o1 = new Object();
@Override
public void run() {
while (count > 0) {
try {
Thread.sleep(50);
} catch (InterruptedException e) {
e.printStackTrace();
}
sale();
}
}
public void sale() {
Integer a=1;
synchronized (a) {
if (count > 0) {
System.out.println(Thread.currentThread().getName() + ",出售第" + (100 - count + 1) + "票");
count--;
}
}
}
}
public class ThreadDemo {
public static void main(String[] args) {
ThreadTrain threadTrain = new ThreadTrain();
Thread t1 = new Thread(threadTrain);
Thread t2 = new Thread(threadTrain);
t1.start();
t2.start();
}
}
同步函数写法比较简单，主要在函数前加上synchronized就可以了。也就是如下所示：
public synchronized void sale() {
if (count > 0) {
System.out.println(Thread.currentThread().getName() + ",出售第" + (100 - count + 1) + "票");
count--;
}
}
同步函数使用的什么锁？
同步函数将什么锁起来保证线程同步呢？使用的是this锁。我们可以做一个测试，将this锁起来，看看线程执行情况，代码如下：
class ThreadTrain2 implements Runnable {
private int count = 100;
public boolean flag = true;
private static Object oj = new Object();
@Override
public void run() {
if (flag) {
while (count > 0) {
synchronized (this) {
if (count > 0) {
try {
Thread.sleep(50);
} catch (Exception e) {
}
System.out.println(Thread.currentThread().getName() + ",出售第" + (100 - count + 1) + "票");
count--;
}
}
}
} else {
while (count > 0) {
sale();
}
}
}
public synchronized void sale() {
// 前提 多线程进行使用、多个线程只能拿到一把锁。
// 保证只能让一个线程 在执行 缺点效率降低
// synchronized (oj) {
if (count > 0) {
try {
Thread.sleep(50);
} catch (Exception e) {
}
System.out.println(Thread.currentThread().getName() + ",出售第" + (100 - count + 1) + "票");
count--;
}
// }
}
}
public class ThreadDemo2 {
public static void main(String[] args) throws InterruptedException {
ThreadTrain2 threadTrain1 = new ThreadTrain2();
Thread t1 = new Thread(threadTrain1, "1号窗口");
Thread t2 = new Thread(threadTrain1, "2号窗口");
t1.start();
Thread.sleep(40);
threadTrain1.flag = false;
t2.start();
}
}
这里在run方法中，将this，也就是当前对象直接锁起来了，此时其他线程执行sale时一直拿不到锁，所以我们看到的情况是都是窗口1获得票，窗口2永远没有被执行。
如果我们将sale前的synchronize去掉，或者将run方法中synchronized (this) 中的this换掉，就可正常同步了。
在上面的例子中，如果在sale前加上static将其变成静态同步函数，此时会怎么样呢？
我们知道static变量或者成员函数是属于类的，而不是对象的，所以此时同步函数锁的是该函数所属字节码文件对象，可以使用getClass()方法获取，也可以用当前类名.class表示。完整代码：
class ThreadTrain2 implements Runnable {
private static int count = 100;
public boolean flag = true;
private static Object oj = new Object();
@Override
public void run() {
if (flag) {
while (count > 0) {
//这里也可以用ThreadTrain2.getClass()
synchronized (ThreadTrain2.class) {
if (count > 0) {
try {
Thread.sleep(50);
} catch (Exception e) {
}
System.out.println(Thread.currentThread().getName() + ",出售第" + (100 - count + 1) + "票");
count--;
}
}
}
} else {
while (count > 0) {
sale();
}
}
}
public static synchronized void sale() {
// synchronized (oj) {
if (count > 0) {
try {
Thread.sleep(50);
} catch (Exception e) {
}
System.out.println(Thread.currentThread().getName() + ",出售第" + (100 - count + 1) + "票");
count--;
}
// }
}
}
public class ThreadDemo2 {
public static void main(String[] args) throws InterruptedException {
ThreadTrain2 threadTrain1 = new ThreadTrain2();
Thread t1 = new Thread(threadTrain1, "1号窗口");
Thread t2 = new Thread(threadTrain1, "2号窗口");
t1.start();
Thread.sleep(40);
threadTrain1.flag = false;
t2.start();
}
}
4.Volatile关键字
Volatile关键字的作用是变量在多个线程间可见。看一个例子：
class ThreadVolatileDemo extends Thread {
public boolean flag = true;
@Override
public void run() {
System.out.println("开始执行子线程....");
while (flag) {
}
System.out.println("线程停止");
}
public void setRuning(boolean flag) {
this.flag = flag;
}
}
public class ThreadVolatile {
public static void main(String[] args) throws InterruptedException {
ThreadVolatileDemo threadVolatileDemo = new ThreadVolatileDemo();
threadVolatileDemo.start();
Thread.sleep(3000);
threadVolatileDemo.setRuning(false);
System.out.println("flag 已经设置成false");
Thread.sleep(1000);
System.out.println(threadVolatileDemo.flag);
}
}
在这里已经将结果设置为false了，为什么还会一直运行呢？原因是线程之间是不可见的，读取的是副本，没有及时读取到主内存结果，也就是说第一个threadVolatileDemo.start();执行的时候就将的这里的false在启动的时候就将flag设置为true一直在执行了，后面主线程设置threadVolatileDemo.setRuning(false);时，子线程就没有接收到flag的变化。
这时候就需要使用volatile关键字解决线程之间的可见行，强制子线程每次读取该值的时候都去“主内存”中取值。
volatile可以保证线程之间可见性，但是不能保证原子性。看一个例子：
public class VolatileNoAtomic extends Thread {
private volatile static int count = 0;
private void addCount() {
//System.out.printf(getName() + " init count:" + count + " ");
for (int i = 0; i < 1000; i++) {
count++;
}
System.out.println("count:" + count);
}
public void run() {
addCount();
}
public static void main(String[] args) {
VolatileNoAtomic[] arr = new VolatileNoAtomic[100];
for (int i = 0; i < 10; i++) {
arr[i] = new VolatileNoAtomic();
}
/**/
for (int i = 0; i < 10; i++) {
arr[i].start();
}
}
}
程序预期的结果是每个线程拿到一个count的累加初始值，然后依次加1000次，并输出结果。如果执行你会发现，所有的count 初始值都是0，而结果则不一定有10000。这是因为volatile仅仅保证各个线程都能读到,而在执行count++的时候，不能保证所有的操作都是原子的。解决方法是将count定义为原子类，也就是：
public class VolatileNoAtomic extends Thread {
// private volatile static int count = 0;
private static AtomicInteger count = new AtomicInteger(0);
private void addCount() {
// System.out.printf(getName() + " init count:" + count + " ");
for (int i = 0; i < 1000; i++) {
// count++;
count.incrementAndGet();
}
System.out.println("count:" + count);
}
public void run() {
addCount();
}
public static void main(String[] args) {
VolatileNoAtomic[] arr = new VolatileNoAtomic[100];
for (int i = 0; i < 10; i++) {
arr[i] = new VolatileNoAtomic();
}
/**/
for (int i = 0; i < 10; i++) {
arr[i].start();
}
}
}
这时候打印的结果就一定会有一个输出为10000
4.ThreadLocal关键字
该关键字的作用是为使用该变量的每个线程提供一个独立的副本，所以每个线程可以独立地改变自己的副本，而不影响其他线程对应的副本。
ThreadLocal类接口很简单，只有4个方法，我们先来了解一下：
• void set(Object value)设置当前线程的线程局部变量的值。
• public Object get()该方法返回当前线程所对应的线程局部变量。
• public void remove()将当前线程局部变量的值删除，目的是为了减少内存的占用，该方法是JDK 5.0新增的方法。需要指出的是，当线程结束后，对应该线程的局部变量将自动被垃圾回收，所以显式调用该方法清除线程的局部变量并不是必须的操作，但它可以加快内存回收的速度。
• protected Object initialValue()返回该线程局部变量的初始值，该方法是一个protected的方法，显然是为了让子类覆盖而设计的。这个方法是一个延迟调用方法，在线程第1次调用get()或set(Object)时才执行，并且仅执行1次。ThreadLocal中的缺省实现直接返回一个null。例子：创建三个线程，每个线程生成自己独立的序列号。
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;
}
}
public class ThreadLocaDemo2 extends Thread {
private Res res;
public ThreadLocaDemo2(Res res) {
this.res = res;
}
@Override
public void run() {
for (int i = 0; i < 3; i++) {
System.out.println(Thread.currentThread().getName() + "---" + "i---" + i + "--num:" + res.getNum());
}
}
public static void main(String[] args) {
Res res = new Res();
ThreadLocaDemo2 threadLocaDemo1 = new ThreadLocaDemo2(res);
ThreadLocaDemo2 threadLocaDemo2 = new ThreadLocaDemo2(res);
ThreadLocaDemo2 threadLocaDemo3 = new ThreadLocaDemo2(res);
threadLocaDemo1.start();
threadLocaDemo2.start();
threadLocaDemo3.start();
}
}
转载：https://blog.csdn.net/xueyushenzhou/article/details/105912575