多线程(二)线程安全

什么是线程安全问题？

当多个线程同时对一个全局变量做写操作时，可能线程之间会互相影响，导致数据有问题。这种现象就叫做线程安全问题。

 

解决办法

思路是不要让多个线程对同一个全局变量做写的操作。

为此可以使用同步synchronized或锁(lock)。

原理是线程需要拿到锁才能执行，执行完后会释放锁，然后另一个线程拿到锁，开始执行。多个线程依次执行，即同步，线程之间互不干扰。缺点是多个线程需要判断锁，较为耗费资源、效率不高。

 

同步代码块

将可能会发现线程问题的代码给包括起来。

synchronized(对象)    //这个对象可以为任意对象

{

       //需要同步的代码

}

上述的对象，就可以理解为是一个锁，持有锁的对象可以执行，没持有锁的线程即使获取cpu的执行权，也执行不了。

同步的前提：

1、必须要有两个或两个以上的线程。

2、必须是多个线程使用同一个锁。

 

 

同步函数

在方法上修饰synchronized称为同步函数。

public synchronized void test(){

         //同步代码

}

同步函数使用的是this锁。在一个线程中使用同步代码块，用this锁；另一个锁使用同步函数，可以发现两个线程是同步的。说明同步函数使用的是this锁。

 

 

多线程编程三大特性

原子性：一个操作或多个操作要么全部执行，要么全部不执行。例如银行转账问题。另外，一个操作中cpu可能中途暂停然后再调度，导致不能保证原子性。

可见性：当多个线程访问同一个变量时，一个线程修改了这个变量的值，其它线程能够立即看得到修改的值。

有序性：程序执行的顺序按照代码的先后顺序执行。例如编译器为了提高程序效率，可能对代码进行重排序。

多线程编程要确保并发程序正确地执行，必须要保证原子性、可见性以及有序性，缺一不可，不然就可能导致结果执行不正确。

 

 

JAVA内存模型（JAVA MEMORY MODEL，简称JMM）

内存模型的目的就是为了保证并发编程中可以满足原子性、可见性和有序性。

内存模型定义了共享内存系统中多线程程序读写操作行为的规范，采用限制处理器优化和使用内存屏障的方式。

java中提供了一系列和并发处理相关的关键字，如synchronized、volatile、final、concurrent包等，这些其实就是java内存模型封装了底层实现后提供给程序员使用的一些关键字。

 

Volatile关键字

作用是变量在多个线程之间可见。

public class ThreadDemo {
	
	public static void main(String[] args) throws InterruptedException {
		VolatileDemo volatileDemo = new VolatileDemo();
		volatileDemo.start();
		Thread.sleep(2000);
		volatileDemo.setFlag(false);
		System.out.println("flag改成了false");
		Thread.sleep(1000);
		System.out.println(volatileDemo.flag);
	}
}

class VolatileDemo extends Thread{
	public boolean flag = true;

	@Override
	public void run() {
		while(flag) {
			
		}
		System.out.println("线程停止");
	}
	
	public void setFlag(boolean flag) {
		this.flag = flag;
	}
}

上述的demo执行完成后结构如下图所示

为什么flag已经改成false了，线程还是没有停止？

原因是在main线程调用方法修改了flag的值，但是在volatiledemo线程是不知道这个值修改了的，在while中读到的flag的值是缓存副本的值，没有读取到主内存中flag的值。即副本flag是true，主内存中flag的值是false。

解决办法就是给flag变量加上volatile关键字修饰，强制线程每次读取该值的时候都去主内存中取值。

 

需要注意的是，volatile只能解决可见性，不能保证原子性，因此不能用来同步。

public class VolatileNoAtomic extends Thread {
	private static volatile int count;

	// private static AtomicInteger count = new AtomicInteger(0);
	private static void addCount() {
		for (int i = 0; i < 1000; i++) {
			count++;
			// count.incrementAndGet();
		}
		System.out.println(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();
		}
	}

}

多次运行，可以发现有时候会出现线程安全问题。

 

 

AtomicInteger原子类

AtomicInteger是一个提供原子操作的Integer类，通过线程安全的方式操作加减。

public class VolatileNoAtomic extends Thread {
	static int count = 0;
	private static AtomicInteger atomicInteger = new AtomicInteger(0);

	@Override
	public void run() {
		for (int i = 0; i < 1000; i++) {
			//等同于i++
			atomicInteger.incrementAndGet();
		}
		System.out.println(count);
	}

	public static void main(String[] args) {
		// 初始化10个线程
		VolatileNoAtomic[] volatileNoAtomic = new VolatileNoAtomic[10];
		for (int i = 0; i < 10; i++) {
			// 创建
			volatileNoAtomic[i] = new VolatileNoAtomic();
		}
		for (int i = 0; i < volatileNoAtomic.length; i++) {
			volatileNoAtomic[i].start();
		}
	}

}