并发编程之多线程线程安全

时间  2019-12-18
标签 并发 编程 之多 线程 安全 栏目 系统安全 繁體版
原文   原文链接

著做权归做者全部，任何形式的转载都请联系做者得到受权并注明出处。

什么是线程安全？

为何有线程安全问题？

当多个线程同时共享，同一个全局变量或静态变量，作写的操做时，可能会发生数据冲突问题，也就是线程安全问题。可是作读操做是不会发生数据冲突问题。java

案例: 需求如今有100张火车票，有两个窗口同时抢火车票，请使用多线程模拟抢票效果。git

public class ThreadTrain implements Runnable {
    private int trainCount = 10;

    @Override
    public void run() {
        while (trainCount > 0) {
            try {
                Thread.sleep(500);
                sale();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    private void sale() {
        if (trainCount > 0) {
            --trainCount;
            System.out.println(Thread.currentThread().getName() + ",出售第" + (10 - trainCount) + "张票");
        }
    }

    public static void main(String[] args) {
        ThreadTrain threadTrain = new ThreadTrain();
        Thread t1 = new Thread(threadTrain, "1台");
        Thread t2 = new Thread(threadTrain, "2台");
        t1.start();
        t2.start();
    }
}
复制代码

运行结果:程序员

一号窗口和二号窗口同时出售火车第九九张,部分火车票会重复出售。 结论发现，多个线程共享同一个全局成员变量时，作写的操做可能会发生数据冲突问题。github

线程安全解决办法:

问: 如何解决多线程之间线程安全问题
答: 使用多线程之间同步synchronized或使用锁(lock)。编程

问: 为何使用线程同步或使用锁能解决线程安全问题呢？
答: 将可能会发生数据冲突问题(线程不安全问题)，只能让当前一个线程进行执行。代码执行完成后释放锁，让后才能让其余线程进 行执行。这样的话就能够解决线程不安全问题。缓存

问: 什么是多线程之间同步
答: 当多个线程共享同一个资源,不会受到其余线程的干扰。安全

问: 什么是多线程同步
答: 当多个线程共享同一个资源,不会受到其余线程的干扰。bash

内置的锁

Java提供了一种内置的锁机制来支持原子性，每个Java对象均可以用做一个实现同步的锁，称为内置锁，线程进入同步代码块以前自动获取到锁，代码块执行完成正常退出或代码块中抛出异常退出时会释放掉锁多线程

内置锁为互斥锁，即线程A获取到锁后，线程B阻塞直到线程A释放锁，线程B才能获取到同一个锁 内置锁使用synchronized关键字实现，synchronized关键字有两种用法：app

  1. 修饰须要进行同步的方法（全部访问状态变量的方法都必须进行同步），此时充当锁的对象为调用同步方法的对象
  2. 同步代码块和直接使用synchronized修饰须要同步的方法是同样的，可是锁的粒度能够更细，而且充当锁的对象不必定是this，也能够是其它对象，因此使用起来更加灵活

同步代码块synchronized

就是将可能会发生线程安全问题的代码，给包括起来。
synchronized(同一个数据){
 可能会发生线程冲突问题
}
就是同步代码块 
synchronized(对象)//这个对象能够为任意对象 
{ 
    须要被同步的代码 
} 
复制代码

对象如同锁，持有锁的线程能够在同步中执行，没持有锁的线程即便获取CPU的执行权，也进不去，同步的前提：

  1. 必需要有两个或者两个以上的线程
  2. 必须是多个线程使用同一个锁

必须保证同步中只能有一个线程在运行
好处： 解决了多线程的安全问题
弊端： 多个线程须要判断锁，较为消耗资源、抢锁的资源。 代码样例:

private void sale() {
        synchronized (this) {
            if (trainCount > 0) {
                --trainCount;
                System.out.println(Thread.currentThread().getName() + ",出售第" + (10 - trainCount) + "张票");
            }
        }
    }
复制代码

同步方法

在方法上修饰synchronized 称为同步方法

public synchronized void sale() {
	if (trainCount > 0) {
		System.out.println(Thread.currentThread().getName() + ",出售第" + (100 - trainCount + 1) + "张票");
		trainCount--;
	}
}
复制代码

同步方法使用的是什么锁？

答：同步函数使用this锁。
证实方式: 一个线程使用同步代码块(this明锁),另外一个线程使用同步函数。若是两个线程抢票不能实现同步，那么会出现数据错误。 参考：方法锁，对象锁以及类锁的用法与区别

package com.itmayiedu;

class Thread0009 implements Runnable {
    private int trainCount = 10;
    private Object oj = new Object();
    public boolean flag = true;

    public void run() {

        if (flag) {
            while (trainCount > 0) {
                synchronized (this) {
                    try {
                        Thread.sleep(10);
                    } catch (Exception e) {
                        // TODO: handle exception
                    }
                    if (trainCount > 0) {
                        System.out.println(Thread.currentThread().getName() + "," + "出售第" + (10 - trainCount + 1) + "票");
                        trainCount--;
                    }
                }

            }
        } else {
            while (trainCount > 0) {
                sale();
            }

        }

    }

    public synchronized void sale() {
        try {
            Thread.sleep(10);
        } catch (Exception e) {
            // TODO: handle exception
        }
        if (trainCount > 0) {
            System.out.println(Thread.currentThread().getName() + "," + "出售第" + (10 - trainCount + 1) + "票");
            trainCount--;
        }

    }
}

public class Test009 {
    public static void main(String[] args) throws InterruptedException {
        Thread0009 threadTrain1 = new Thread0009();
        Thread0009 threadTrain2 = new Thread0009();
        threadTrain2.flag = false;

        Thread t1 = new Thread(threadTrain1, "窗口1");
        Thread t2 = new Thread(threadTrain2, "窗口2");

        t1.start();
        Thread.sleep(40);
        t2.start();
    }
}
复制代码

静态同步函数

方法上加上static关键字，使用synchronized 关键字修饰 或者使用类.class文件。 静态的同步函数使用的锁是 该函数所属字节码文件对象 能够用 getClass方法获取，也能够用当前 类名.class 表示。 代码样例:

public static void sale() {
		synchronized (ThreadTrain3.class) {
			if (trainCount > 0) {
				System.out.println(Thread.currentThread().getName() + ",出售第" + (100 - trainCount + 1) + "张票");
				trainCount--;
			}
		}
}
复制代码

总结：
synchronized 修饰方法使用锁是当前this锁。
synchronized 修饰静态方法使用锁是当前类的字节码文件

多线程死锁

同步中嵌套同步,致使锁没法释放

public class ThreadTrain3 implements Runnable {
	private static int trainCount = 100;

	@Override
	public void run() {
		while (trainCount > 0) {
			try {
				Thread.sleep(50);
			} catch (Exception e) {

			}
			sale();
		}
	}

	public static void sale() {
		synchronized (ThreadTrain3.class) {
			if (trainCount > 0) {
				System.out.println(Thread.currentThread().getName() + ",出售第" + (100 - trainCount + 1) + "张票");
				trainCount--;
			}
		}

	}

	public static void main(String[] args) {
		ThreadTrain3 threadTrain = new ThreadTrain3();
		Thread t1 = new Thread(threadTrain, "①号");
		Thread t2 = new Thread(threadTrain, "②号");
		t1.start();
		t2.start();
	}

}
复制代码

什么是Threadlocal

ThreadLocal提升一个线程的局部变量，访问某个线程拥有本身局部变量。 当使用ThreadLocal维护变量时，ThreadLocal为每一个使用该变量的线程提供独立的变量副本，因此每个线程均可以独立地改变本身的副本，而不会影响其它线程所对应的副本。 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 Test006 extends Thread {

	private Res res;

	public Test006(Res res) {
		this.res = res;
	}

	@Override
	public void run() {
		for (int i = 0; i < 3; i++) {
			System.out.println(Thread.currentThread().getName() + "," + res.getNum());
		}
	}

	public static void main(String[] args) {
		Res res = new Res();
		Test006 t1 = new Test006(res);
		Test006 t2 = new Test006(res);

		t1.start();
		t2.start();
	}

}
复制代码

ThreadLoca实现原理， ThreadLoca经过map集合，Map.put(“当前线程”,值)；

多线程有三大特性

什么是原子性

即一个操做或者多个操做 要么所有执行而且执行的过程不会被任何因素打断，要么就都不执行。 一个很经典的例子就是银行帐户转帐问题：
好比从帐户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，由于这打破了依赖关系。
显然重排序对单线程运行是不会有任何问题，而多线程就不必定了，因此咱们在多线程编程时就得考虑这个问题了。

Java内存模型

共享内存模型指的就是Java内存模型(简称JMM)，JMM决定一个线程对共享变量的写入时,能对另外一个线程可见。 从抽象的角度来看，JMM定义了线程和主内存之间的抽象关系：线程之间的共享变量存储在主内存（mainmemory）中，每一个线程都有一个私有的本地内存（local memory），本地内存中存储了该线程以读/写共享变量的副本。 本地内存是JMM的一个抽象概念，并不真实存在。它涵盖了缓存，写缓冲区，寄存器以及其余的硬件和编译器优化。

从上图来看，线程A与线程B之间如要通讯的话，必需要经历下面2个步骤：

  1. 首先，线程A把本地内存A中更新过的共享变量刷新到主内存中去。
  2. 而后，线程B到主内存中去读取线程A以前已更新过的共享变量。

下面经过示意图来讲明这两个步骤：

如上图所示，本地内存A和B有主内存中共享变量x的副本。假设初始时，这三个内存中的x值都为0。线程A在执行时，把更新后的x值（假设值为1）临时存放在本身的本地内存A中。当线程A和线程B须要通讯时，线程A首先会把本身本地内存中修改后的x值刷新到主内存中，此时主内存中的x值变为了1。随后，线程B到主内存中去读取线程A更新后的x值，此时线程B的本地内存的x值也变为了1。

从总体来看，这两个步骤实质上是线程A在向线程B发送消息，并且这个通讯过程必需要通过主内存。JMM经过控制主内存与每一个线程的本地内存之间的交互，来为java程序员提供内存可见性保证。

总结： 什么是Java内存模型：java内存模型简称jmm，定义了一个线程对另外一个线程可见。共享变量存放在主内存中，每一个线程都有本身的本地内存，当多个线程同时访问一个数据的时候，可能本地内存没有及时刷新到主内存，因此就会发生线程安全问题。

Volatile

可见性也就是说一旦某个线程修改了该被volatile修饰的变量，它会保证修改的值会当即被更新到主存，当有其余线程须要读取时，能够当即获取修改以后的值。 在Java中为了加快程序的运行效率，对一些变量的操做一般是在该线程的寄存器或是CPU缓存上进行的，以后才会同步到主存中，而加了volatile修饰符的变量则是直接读写主存。

Volatile 保证了线程间共享变量的及时可见性，但不能保证原子性

class ThreadDemo004 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 Test0004 {
    public static void main(String[] args) throws InterruptedException {
        ThreadDemo004 threadDemo004 = new ThreadDemo004();
        threadDemo004.start();
        Thread.sleep(3000);
        threadDemo004.setRuning(false);
        System.out.println("flag已經改為false");
        Thread.sleep(1000);
        System.out.println("flag:" + threadDemo004.flag);
    }
}
复制代码

已经将结果设置为fasle为何？还一直在运行呢。
缘由:线程之间是不可见的，读取的是副本，没有及时读取到主内存结果。 解决办法使用Volatile关键字将解决线程之间可见性, 强制线程每次读取该值的时候都去“主内存”中取值

Volatile特性

  1. 保证此变量对全部的线程的可见性，这里的“可见性”，如本文开头所述，当一个线程修改了这个变量的值，volatile 保证了新值能当即同步到主内存，以及每次使用前当即从主内存刷新。但普通变量作不到这点，普通变量的值在线程间传递均须要经过主内存（详见：Java内存模型）来完成。
  2. 禁止指令重排序优化。有volatile修饰的变量，赋值后多执行了一个“load addl $0x0, (%esp)”操做，这个操做至关于一个内存屏障（指令重排序时不能把后面的指令重排序到内存屏障以前的位置），只有一个CPU访问内存时，并不须要内存屏障；（什么是指令重排序：是指CPU采用了容许将多条指令不按程序规定的顺序分开发送给各相应电路单元处理）。

volatile 性能：
  volatile 的读性能消耗与普通变量几乎相同，可是写操做稍慢，由于它须要在本地代码中插入许多内存屏障指令来保证处理器不发生乱序执行。

Volatile与Synchronized区别

  1. 从而咱们能够看出volatile虽然具备可见性可是并不能保证原子性。
  2. 性能方面，synchronized关键字是防止多个线程同时执行一段代码，就会影响程序执行效率，而volatile关键字在某些状况下性能要优于synchronized。

可是要注意volatile关键字是没法替代synchronized关键字的，由于volatile关键字没法保证操做的原子性。

重排序

数据依赖性

若是两个操做访问同一个变量，且这两个操做中有一个为写操做，此时这两个操做之间就存在数据依赖性。数据依赖分下列三种类型：

名称 代码示例 说明
写后读 a = 1;b = a; 写一个变量以后，再读这个位置。
写后写 a = 1;a = 2; 写一个变量以后，再写这个变量。
读后写 a = b;b = 1; 读一个变量以后，再写这个变量。

上面三种状况，只要重排序两个操做的执行顺序，程序的执行结果将会被改变。 前面提到过，编译器和处理器可能会对操做作重排序。编译器和处理器在重排序时，会遵照数据依赖性，编译器和处理器不会改变存在数据依赖关系的两个操做的执行顺序。 注意，这里所说的数据依赖性仅针对单个处理器中执行的指令序列和单个线程中执行的操做，不一样处理器之间和不一样线程之间的数据依赖性不被编译器和处理器考虑。

as-if-serial语义

s-if-serial语义的意思指：无论怎么重排序（编译器和处理器为了提升并行度），（单线程）程序的执行结果不能被改变。编译器，runtime 和处理器都必须遵照as-if-serial语义。

为了遵照as-if-serial语义，编译器和处理器不会对存在数据依赖关系的操做作重排序，由于这种重排序会改变执行结果。可是，若是操做之间不存在数据依赖关系，这些操做可能被编译器和处理器重排序。为了具体说明，请看下面计算圆面积的代码示例：

double pi  = 3.14;    //A
double r   = 1.0;     //B
double area = pi * r * r; //C
复制代码

上面三个操做的数据依赖关系以下图所示：

如上图所示，A和C之间存在数据依赖关系，同时B和C之间也存在数据依赖关系。所以在最终执行的指令序列中，C不能被重排序到A和B的前面（C排到A和B的前面，程序的结果将会被改变）。但A和B之间没有数据依赖关系，编译器和处理器能够重排序A和B之间的执行顺序。下图是该程序的两种执行顺序：

as-if-serial语义把单线程程序保护了起来，遵照as-if-serial语义的编译器，runtime 和处理器共同为编写单线程程序的程序员建立了一个幻觉：单线程程序是按程序的顺序来执行的。as-if-serial语义使单线程程序员无需担忧重排序会干扰他们，也无需担忧内存可见性问题。

程序顺序规则

根据happens- before的程序顺序规则，上面计算圆的面积的示例代码存在三个happens- before关系：

  1. A happens- before B；
  2. B happens- before C；
  3. A happens- before C；

这里的第3个happens- before关系，是根据happens- before的传递性推导出来的。 这里A happens- before B，但实际执行时B却能够排在A以前执行（看上面的重排序后的执行顺序）。在第一章提到过，若是A happens- before B，JMM并不要求A必定要在B以前执行。JMM仅仅要求前一个操做（执行的结果）对后一个操做可见，且前一个操做按顺序排在第二个操做以前。这里操做A的执行结果不须要对操做B可见；并且重排序操做A和操做B后的执行结果，与操做A和操做B按happens- before顺序执行的结果一致。在这种状况下，JMM会认为这种重排序并不非法（not illegal），JMM容许这种重排序。 在计算机中，软件技术和硬件技术有一个共同的目标：在不改变程序执行结果的前提下，尽量的开发并行度。编译器和处理器听从这一目标，从happens- before的定义咱们能够看出，JMM一样听从这一目标。

重排序对多线程的影响

/**
 * 重排序
 */
class ReorderExample {
	int a = 0;
	boolean flag = false;

	public void writer() {
		a = 1; // 1
		flag = true; // 2
		System.out.println("writer");
	}

	public void reader() {
		if (flag) { // 3
			int i = a * a; // 4
			System.out.println("i:" + i);
		}
		System.out.println("reader");
	}

	public static void main(String[] args) {
		ReorderExample reorderExample = new ReorderExample();
		Thread t1 = new Thread(new Runnable() {

			@Override
			public void run() {
				reorderExample.writer();
			}
		});
		Thread t2 = new Thread(new Runnable() {

			@Override
			public void run() {
				reorderExample.reader();
			}
		});
		t1.start();
		t2.start();

	}
}
复制代码

flag变量是个标记，用来标识变量a是否已被写入。这里假设有两个线程A和B，A首先执行writer()方法，随后B线程接着执行reader()方法。线程B在执行操做4时，可否看到线程A在操做1对共享变量a的写入？ 答案是：不必定能看到。 因为操做1和操做2没有数据依赖关系，编译器和处理器能够对这两个操做重排序；一样，操做3和操做4没有数据依赖关系，编译器和处理器也能够对这两个操做重排序。让咱们先来看看，当操做1和操做2重排序时，可能会产生什么效果？请看下面的程序执行时序图：

如上图所示，操做1和操做2作了重排序。程序执行时，线程A首先写标记变量flag，随后线程B读这个变量。因为条件判断为真，线程B将读取变量a。此时，变量a还根本没有被线程A写入，在这里多线程程序的语义被重排序破坏了！

※注：本文统一用红色的虚箭线表示错误的读操做，用绿色的虚箭线表示正确的读操做。

下面再让咱们看看，当操做3和操做4重排序时会产生什么效果（借助这个重排序，能够顺便说明控制依赖性）。下面是操做3和操做4重排序后，程序的执行时序图：

在程序中，操做3和操做4存在控制依赖关系。当代码中存在控制依赖性时，会影响指令序列执行的并行度。为此，编译器和处理器会采用猜想（Speculation）执行来克服控制相关性对并行度的影响。以处理器的猜想执行为例，执行线程B的处理器能够提早读取并计算a*a，而后把计算结果临时保存到一个名为重排序缓冲（reorder buffer ROB）的硬件缓存中。当接下来操做3的条件判断为真时，就把该计算结果写入变量i中。

从图中咱们能够看出，猜想执行实质上对操做3和4作了重排序。重排序在这里破坏了多线程程序的语义！

在单线程程序中，对存在控制依赖的操做重排序，不会改变执行结果（这也是as-if-serial语义容许对存在控制依赖的操做作重排序的缘由）；但在多线程程序中，对存在控制依赖的操做重排序，可能会改变程序的执行结果。

本文代码地址

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程