java入门（4）——线程安全

总算数据结构和数电没有任务了，可以好好写篇博客了，今天正好学了线程安全，就趁热打铁写一下吧。

---

前言

一、什么是线程安全？

程序中有多个线程在操作共享数据，由于线程有4个步骤：创建、就绪、运行、中止，执行顺序会出现不确定性，和预期冲突。

二、线程同步的方式–同步监听器（锁）

1.同步代码块

代码如下（示例）：

synchronized（同步监视器（锁））
{
      //对共享数据的改变。
}

任何引用对象都可以作为锁。
多个线程必须用的一个锁，这个锁往往就是共享数据。（同步监听器的唯一性）

2.同步方法

代码如下（示例）：

public synchronized void test(){}

这个方法本身就是同步的，这时的锁是这个方法所属的线程对象，这时需要保证对象唯一才能保证同步监听器唯一。

3.Lock类

代码如下（示例）：

//创建锁对象
Lock lock=new ReentrantLock();
try{
lock.lock();
//对共享数据的改变
} finally //finally表示一定会执行finally 之后的语句，尽管该方法中有错误。
{
lock.unlock();
}

这个时候也要保证多个线程共用的是同一个Lock，方便起见可以写一个Thread类的接口，Lock是接口的常量，这样保证了唯一性。

三、优缺点

优点：防止出现多个操作改变共享数据，发生跟期望相冲突的问题。
缺点：多线程=>单线程，降低了执行效率。

四、银行转账问题、volatile关键字

1、volatile：

synchronized关键字是防止多个线程同时执行一段代码，那么就会很影响程序执行效率，而volatile关键字在某些情况下性能要优于synchronized，但是要注意volatile关键字是无法替代synchronized关键字的，因为volatile关键字无法保证操作的原子性（即无法保证多个线程先运行完一个再运行另一个）。
比如：

public class test_main {
    static class A {
        volatile int a = 0;
        void increase() {
            a++;
        }
        int getA(){
            return a;
        }
    }

    public static void main(String[] args) {
        A a = new A();

        new Thread(() -> {
            for (int i = 0;i < 1000;i++) {
                a.increase();
                try {
					Thread.sleep(20);
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
            }
            System.out.println(a.getA());
        }).start();
        new Thread(() -> {
            for (int i = 0;i < 2000;i++) {
                a.increase();
            }
            System.out.println(a.getA());
        }).start();
        new Thread(() -> {
            for (int i = 0;i < 3000;i++) {
                a.increase();
            }
            System.out.println(a.getA());
        }).start();
        new Thread(() -> {
            for (int i = 0;i < 4000;i++) {
                a.increase();
            }
            System.out.println(a.getA());
        }).start();
        new Thread(() -> {
            for (int i = 0;i < 5000;i++) {
                a.increase();
            }
            System.out.println(a.getA());
        }).start();
    }
}

volatile的主要作用是使得这个变量让多个线程能够共同看到，使得修改操作总在读出操作之前，实现了及时存储性，使得获取的总是最新的值。

2、银行转账问问题。

主要涉及到多个线程进行转账操作时，再某一时刻读出总钱数（或者某个账户的钱数）时，取出的并不是最及时的钱数。
下面提供三种解决方案：
1、自己写一个BankThread类（继承Thread类），lock类的对象是其中的一个成员变量，每次new新的Thread时，都把公共的lock传过去。转账操作中加上：

try{
lock.lock();
} finally 
{
lock.unlock();
}

2、对Bank类的转账方法前面加上关键字synchronized。
3、在账户的钱数前加上关键字volatile，这样保证每次查看钱数都是最新的结果。

第2种实现详见
chelsi916博主的博客：（讲的很易懂！）
https://blog.csdn.net/chelsi916/article/details/78200135?ops_request_misc=&request_id=&biz_id=102&utm_term=%25E9%2593%25B6%25E8%25A1%258C%25E8%25BD%25AC%25E8%25B4%25A6%25E7%259A%2584%25E7%25BA%25BF%25E7%25A8%258B%25E5%25AE%2589%25E5%2585%25A8%25E9%2597%25AE%25E9%25A2%2598&utm_medium=distribute.pc_search_result.none-task-blog-2_allsobaiduweb~default-4-78200135.first_rank_v2_pc_rank_v29