【并发】共享模型之管程
共享模型之管程
共享问题
package 并发;
public class Test1 {
static int a=0;
public static void main(String[] args) throws InterruptedException {
Thread t1=new Thread(new Runnable() {
@Override
public void run() {
for(int i=0;i<5000;i++){
a++;
}
}
});
Thread t2=new Thread(new Runnable() {
@Override
public void run() {
for(int i=0;i<5000;i++){
a--;
}
}
});
t1.start();;
t2.start();
t1.join();;
t2.join();
System.out.println("a="+a);
}
}
与预期的结果不同
问题分析
以上的结果可能是正数，负数，0为什么呢？ 因为Java中对静态变量的自增，自减并不是原子操作，要彻底理解，必须从字节码进行分析。
例如：对于i++而言，实际会产生如下的JVM字节码指令：
getstatic i //获取静态变量 iconst_1 //准备常量1 iadd //自增 putstatic i //将修改后的值存入静态变量i
而JAVA 的内存模型如下，完成静态变量的自增，自减需要在主存和工作内存中进行数据交换：
如果是单线程，上面的代码是顺序执行(不会交错) 没有问题：
临界区
- 一个程序运行多个线程本身是没有问题的。
- 问题出在多个线程访问共享资源。
- 多个线程读取共享资源其实也没有问题
- 在多个线程对共享资源读写操作时发生指令交集，就会出现问题。
- 一般代码块如果存在对共享资源的多线程读写操作。那么这段代码称为临界区。
Thread t1=new Thread(new Runnable() {
@Override
public void run() {
//临界区
a++;
}
});
Thread t2=new Thread(new Runnable() {
@Override
public void run() {
//临界区
a--;
}
});解决方案
- 阻塞式的解决方案：synchronized \ Lock
- 非阻塞式的解决方案：原子变量
本次课程使用的解决方案式：synchronzied ，来解决上述问题,俗称【对象锁】。
它采用互斥的方式让同一时刻至多只有一个线程能持有【对象锁】，其他想获取这个对象锁就会被阻塞住，这样就能保证拥有锁的线程可以安全的执行临界区内的代码，不用担心上下文的切换。
注意：
虽然java中的互斥和同步都是可以采用synchronized来完成，但还是有区别的。
- 互斥是保证临界区的竟态条件发生，同一时刻只有一个线程执行临界区的代码。
- 同步是由于线程执行的先后，顺序不同，需要一个线程等待其他线程运行到这个点，
synchronzied
语法
synchronized(){
临界区
}解决
package 并发;
import java.util.Date;
public class Test1 {
static Integer a=0;
static Object flag=new Object();
public static void main(String[] args) throws InterruptedException {
Thread t1=new Thread(new Runnable() {
@Override
public void run() {
for(int i=0;i<5000;i++){
//加锁
synchronized (flag){
a++;
}
}
}
});
Thread t2=new Thread(new Runnable() {
@Override
public void run() {
for(int i=0;i<5000;i++){
//加锁
synchronized (flag){
a--;
}
}
}
});
t1.start();;
t2.start();
t1.join();;
t2.join();
System.out.println("a="+a);
}
}
向对象思想改进面
package 并发;
import java.util.Date;
class Test1 {
static Integer a=0;
static Room room=new Room();
public static void main(String[] args) throws InterruptedException {
Thread t1=new Thread(new Runnable() {
@Override
public void run() {
for(int i=0;i<5000;i++){
room.increase();;
}
}
});
Thread t2=new Thread(new Runnable() {
@Override
public void run() {
for(int i=0;i<5000;i++){
room.decrease();;
}
}
});
t1.start();;
t2.start();
t1.join();;
t2.join();
System.out.println("结果是"+room.count);
}
}
class Room {
public static int count=0;
static Object flag=new Object();
public void increase(){
synchronized (flag){
count++;
}
}
public void decrease(){
synchronized (flag){
count--;
}
}
}
方法上的synchronized
语法
synchronized加在普通方法上
class Room {
public static int count=0;
static Object flag=new Object();
public synchronized void increase(){
count++;
}
//等价于 锁住的是自己的对象
public void increase(){
synchronized(this){
count++;
}
}
}synchronized加在静态方法上
class Room {
public static int count=0;
static Object flag=new Object();
public synchronized static void increase(){
count++;
}
//等价于 锁住的是自己的类对象
public static void increase(){
synchronized(Room.class){
count++;
}
}
}不加synchronized方法无法保证原子性
线程安全分析
成员变量和静态变量是否是安全的？
- 如果他们没有共享，则线程安全
- 如果他们被共享了，根据他们的线程是否能改变，又分为两种：
只有读操作，则线程安全。
如果有读写操作，则这段代码是临界区，需要考虑线程安全。
局部变量是否是线程安全的？
- 局部变量是线程安全的
- 但局部变量引用的对象未必。（堆中的变量就可能被共享）
-
- 如果该对象没有逃离方法的作用范围，则是线程安全的。
- 如果该对象逃离方法的作用范围，则需要考虑线程安全
局部变量线程安全分析
public static void test1(){ int i=10; i++; }
每个线程调用test1()方法时局部变量i，会在每个线程的栈帧内存中被创建多份，因此不存在共享
如图：
局部变量的引用稍有不同
先看一个成员变量的例子
class ThreadUnsafe {
ArrayList list = new ArrayList<>();
public void method1(int loopNumber) {
for (int i = 0; i < loopNumber; i++) {
// { 临界区, 会产生竞态条件 method2(); method3();
执行其中一种情况是，如果线程2 还未 add，线程1 remove 就会报错：Exception in thread "Thread1" java.lang.IndexOutOfBoundsException: Index: 0, Size: 0 at java.util.ArrayList.rangeCheck(ArrayList.java:657) at java.util.ArrayList.remove(ArrayList.java:496) at cn.itcast.n6.ThreadUnsafe.method3(TestThreadSafe.java:35) at cn.itcast.n6.ThreadUnsafe.method1(TestThreadSafe.java:26) at cn.itcast.n6.TestThreadSafe.lambda$main$0(TestThreadSafe.java:14) at java.lang.Thread.run(Thread.java:748)分析：无论哪个线程中的 method2 引用的都是同一个对象中的 list 成员变量method3 与 method2 分析相同 // } 临界区 } } private void method2() { list.add("1"); } private void method3() { list.remove(0); }}执行
static final int THREAD_NUMBER = 2;
static final int LOOP_NUMBER = 200;
public static void main(String[] args) {
ThreadUnsafe test = new ThreadUnsafe();
for (int i = 0; i < THREAD_NUMBER; i++) {
new Thread(() -> { test.method1(LOOP_NUMBER); }, "Thread" + i).start(); }}其中一种情况是，如果线程2 还未 add，线程1 remove 就会报错
Exception in thread "Thread1" java.lang.IndexOutOfBoundsException: Index: 0, Size: 0 at java.util.ArrayList.rangeCheck(ArrayList.java:657) at java.util.ArrayList.remove(ArrayList.java:496) at cn.itcast.n6.ThreadUnsafe.method3(TestThreadSafe.java:35) at cn.itcast.n6.ThreadUnsafe.method1(TestThreadSafe.java:26) at cn.itcast.n6.TestThreadSafe.lambda$main$0(TestThreadSafe.java:14) at java.lang.Thread.run(Thread.java:748)
分析：
无论哪个线程中的 method2 引用的都是同一个对象中的 list 成员变量
method3 与 method2 分析相同