羿先生的学习笔记[5]: Java中的线程安全

于 2020-07-02 19:25:20 发布
阅读量136 收藏
点赞数 1
分类专栏： HIT-CS-软件构造
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44253320/article/details/107081808
版权

目录

羿先生的学习笔记[5]: Java中的线程安全

一、线程

并发模块有两种类型：进程(Process)与线程(Thread)。一个进程表示一个虚拟计算机，一个线程表示一个虚拟CPU，线程之间共享内存，可以互相通信。
Java中提供了Thread类，继承Runnable接口。Thread类可以如下使用：

		Thread thread1 = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("hello from thread 1");
            }
        });
        Thread thread2 = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("hello from thread 2");
            }
        });
        thread1.start();
        thread2.start();

向构造方法中提供一个Runnable接口的具体实现，在run()方法中写进程中执行的代码，并调用start()方法执行线程。
此外，也可以显式地指定线程名：

        Thread thread1 = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("hello from thread 1");
            }
        },"thread1");

还可以用自定义的类继承Thread类：

public class MyThread extends Thread{
    @Override
    public void run() {
        System.out.println("my thread");
    }
}

覆写run()方法并调用start()方法执行进程。

二、线程不安全产生的原因

我们来看一个产生线程不安全的例子：

public class Count{
    private int count = 0;
    private void add() throws InterruptedException {
        int c = count + 1;
        Thread.sleep(1);
        count = c;
    }
    public void test(int n){
        for(int i = 0; i < n; i++){
            new Thread(new Runnable() {
                @Override
                public void run() {
                    try {
                        add();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }).start();
        }
    }
    public int getCount(){
        return count;
    }
}

这段代码中，add()方法每次给count值加一，test()方法中通过n个线程调用n次add()方法，那么，count的值将变为n。然而事实真的如此吗？我们来测试一下：

public class Main {
    public static void main(String[] args) throws InterruptedException {
        Count c = new Count();
        c.test(10);
        Thread.sleep(20);//等待子线程执行完毕
        System.out.println(c.getCount());
    }
}

多次测试，得到了一些不同结果，笔者进行五次测试分别得到2，1，2，1，1的输出。
产生的输出不是我们预期的10，原因在于各个线程之间的竞争。我们的CPU的一个核对于多线程的处理并非是绝对意义上的并行，即同一时间执行多项任务，而是通过时间分片的方式实现：
在这里插入图片描述
具体来说，在一个双线程的程序中，CPU可以先处理线程1的某一部分将其挂起处理线程2的某一部分，再将线程2挂起继续处理线程1。同一时刻上CPU至多处理一个线程。并且，CPU在进程间转换的行为在程序员的视角是不可预测的。
再具体到我们的例子，子线程在CPU的核上执行到sleep()方法时会被挂起，以让出资源执行其他线程。假如有两个线程A、B，A线程执行完c = count + 1语句，得到c = 1，此时count的值并未被改变。此时执行线程B，B线程执行执行c = count + 1语句，同样得到c = 1。因此就会产生线程不安全的因素。
那么有人可能会问，如果add()方法中不执行sleep()，而写成

    private void add() {
        count++;
    }

会产生线程不安全吗？事实上，count++虽然在Java中体现为一句，但Java语句不能被CPU直接执行，需要编译成机器指令。CPU所能执行的单条指令我们称为原子指令，简单的把变量自身+1对应三条原子指令：

  1. 从内存中取出count值放入寄存器中；
  2. 寄存器中值+1；
  3. 将寄存器中值写回内存；

CPU核同样可以在某条原子语句后切换线程。线程不安全的根本原因在于，我们无法预测CPU在哪条原子语句后切换线程。例如我们运行test(2)。有两个线程A、B，假定CPU先执行A的1、2，挂起A；执行B的1、2，挂起B；此时A、B线程中寄存器的值均为1，CPU将其再写回内存，count值就变成了1而非我们希望得到的2。

三、确保线程安全的方法

线程安全指的是数据类型或是方法在多线程中无论有多少处理器、OS如何调度线程，不要求调用者满足某种线程安全的义务的情况下均能正确地执行。
实现线程安全有四种方法：

1.限制数据共享

将可变数据限制在线程内部以避免竞争，并且不允许任何线程直接对其进行读写操作。核心思想：线程之间不共享可变(mutable)数据类型。如果一个ADT的rep中包含 mutable的属性且多线程之间 对其进行mutator操作，那么 就很难使用confinement策略 来确保该ADT是线程安全的。

2.不可变性

使用不可变数据类型和不可变引用，避免多线程之间的竞争情况。 不可变数据通常是线程安全的。
关于不可见类型可详见我的另一篇文章。

3.使用线程安全的数据类型

如果必须要用mutable的数据类型在多线程之间共享数据，要使用线程安全的数据类型。 在JDK中的类，文档中明确指明了是否线程安全。一般来说， JDK同时提供两个相同功能的类，一个是线程安全的，另一个不是，原因在于，线程安全的类一般性能上受影响 。例如StringBuffer类与StringBuilder类
在这里插入图片描述
集合类，如List,Map,Set都是线程不安全的。可以使用线程安全的版本替代：

private static Map<Integer,Boolean> cache = Collections.synchronizedMap(new HashMap<>());

但在线程安全的集合类中，执行其上某个操作是threadsafe的，但如果多个操作放在一起，仍旧不安全。例如：

if ( !lst.isEmpty()) {
	String s = lst.get(0);
	... 
}

仍可能产生线程间的干扰。例如线程A中执行上述代码，判断lst为空后被CPU挂起，CPU执行线程B，清空了lst。这时再返回线程A就会产生异常。
此外，使用iterator或是循环遍历也是不安全的，应当按需要进行加锁。

4.锁与同步

当我们不得不在多线程间共享mutable类型的数据时，就要用到锁机制，使某个线程获得对数据的独家修改权，其他线程被阻塞，不得访问。
Java中提供了synchronized关键字，可以锁定某对象，使得该对象只能被一个进程独占。例：

/**
* 同步线程
*/
class SyncThread implements Runnable {
        private static int count;

        public SyncThread() {
            count = 0;
        }

        public void run() {
            synchronized(this) {
                for (int i = 0; i < 5; i++) {
                    try {
                        System.out.println(Thread.currentThread().getName() + ":" + (count++));
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }

        public int getCount() {
            return count;
        }
}

如下调用：

SyncThread syncThread = new SyncThread();
Thread thread1 = new Thread(syncThread, "SyncThread1");
Thread thread2 = new Thread(syncThread, "SyncThread2");
thread1.start();
thread2.start();

得到结果

SyncThread1:0
SyncThread1:1
SyncThread1:2
SyncThread1:3
SyncThread1:4
SyncThread2:5
SyncThread2:6
SyncThread2:7
SyncThread2:8
SyncThread2:9

回到我们在上文所举的线程不安全的例子，我们同样可以用synchronized关键字修饰：

public class Count{
    private int count = 0;
    private synchronized void add() throws InterruptedException {
        int c = count + 1;
        Thread.sleep(1);
        count = c;
    }
    public void test(int n){
        for(int i = 0; i < n; i++){
            new Thread(new Runnable() {
                @Override
                public void run() {
                    try {
                        add();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }).start();
        }
    }
    public int getCount(){
        return count;
    }
}

public class Main {
    public static void main(String[] args) throws InterruptedException {
        Count c = new Count();
        c.test(10);
        Thread.sleep(20);//等待子线程执行完毕
        System.out.println(c.getCount());
    }
}

得到预期的输出10。
synchronized关键字修饰instance方法时，以下两种用法是等价的：

public synchronized void myMethod(){
	//some code
}

public void myMethod(){
	synchronized (this) {
		//some code
	}
}

修饰static方法时如下两种用法等价：

public class MyClass(){
	public synchronized static void myStaticMethod(){
		//some code
	}
}

public class MyClass(){
	public static void myStaticMethod(){
		synchronized (MyClass.class) {
			//some codeM
		}M
	}
}

我们有时不希望对整个对象加锁，例如线程A访问加锁的方法a时我们希望线程B能正常访问方法b，此时我们也有对应的办法实现特定代码段的加锁：

public class MyClass(){
	Object lock = new Object();
	public void methodA(){
		//some code
		synchronized (lock){
			//some code
		}
		//some code
	}
	public void methodB(){
		//some code
	}
}

通常而言，对所有ADT的rep访问都需要加锁。需要注意的是，这种方法会显著地影响程序运行效率。也正因此，Java提供的mutable类大部分都是线程不安全的。

羿先生
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值