学习 Java 多线程的一些思考

独占技术是用来保障对象稳固不变，并且防止即便是霎时的状态抵触所带来的的影响。所有的办法都基于一下三个根本策略：

1. 通过确保所有的办法从不同时批改一个对象表现形式，也就是对象永远不会进入不统一的状态来打消局部或者所有的独占管制须要
2. 通过加锁或者其余的动静机制来保障，一个对象在同一时刻只能被一个线程拜访

3. 通过暗藏或者线制对象的使用权，来结构性地保障只能有一个线程能够应用该对象

   不变性

   具备不变性最简略的对象，是对象中基本没有数据。因而，它们的办法都是没有状态的，能够了解为这些办法不依赖于任何对象的任何数据。例如：

   public class StatelessAdder {public static int adder(int a,int b){return a + b;}

   同样的安全性在具备 final 关键字润饰的数据的类中也实用。这样的类实例不会面临底层的读 - 写抵触和写 - 写抵触。因为其值不会被改写。并且，只有它们的初始值是以一种统一的、正当的形式创立，那么这些对象在更高的层面上也不会呈现不变性方面的谬误，例如：

   class ImmutableAdder{
    private final int offset;
    public ImmutableAdder(int a){offset = a;}
    public int addOffset(int b){return offset + b;}
   }

   构造

   在构造函数执行完结之前，不能拜访对象的数据
   和串行编程相比，在并发编程中这一点更难以保障。构造函数应该只执行与初始化数据相干的操作 。 如果一个办法依赖于对象初始化实现，那么构造函数就不应该调用该办法。如果一个对象是在其余类可存取的成员变量或者表中创立的，那么构造函数应该防止应用该对象的援用，防止用 this 关键字来调用其余的办法。能够了解为，要防止 this 产生的透露谬误

   同步

   应用锁能够防止在底层的存储抵触和相应的高层面上的不变束缚抵触，例如：

   class Event{
    private int n = 0;
    public int add(){
        ++n;
        ++n;
        return n;
    }
   }

   上述程序中没有加锁，如果多个线程同时执行 Event 中的 add()办法时，可能会造成数据不统一谬误。

   加锁示例:

   class Event{
   private int n = 0;
   public synchronized int add(){

    ++n;
    ++n;
    return n;

   }
   }

上述程序，在 add()办法增加了 synchronized 关键字，这样就能够防止抵触的执行路线

机制

每一个 Object 类以及子类的实例都领有一把锁。而 int 以及 float 等根本类型都不是 Object 类。根本类型只能通过蕴含他们的对象被锁住。每一个独自的成员变量都不能标记为 synchronized。锁只能在成员变量的办法中利用。成员变量能够被申明为 volatile 类型，这将影响成员变量的原子性，可见性和程序性。
蕴含根本类型元素的数组也是领有锁的对象，然而数组中的根本元素却没有。锁住 Object 类型的数组却不能锁住他们其中的根本元素。
Class 的实例是 Object，Class 对象的相干锁能够用在以 static synchronized 申明的办法中。
synchronized 的用法：

synchronized void func(){...} 
void func(){synchronized(this){...}}

synchronized 关键字不属于办法签名的一部分，所以子类继承父类的时候，synchronized 修饰符不会被继承。因而，接口中的办法不能被生命为 synchronized。同样地，构造函数不能被申明为 synchronized，构造函数中的程序能够被申明为 synchronized。
子类和父类的办法应用同一个锁，然而外部类的锁和它的外部类无关，然而，一个非动态的外部类能够锁住它的外部类，liru :
synchronized (OuterClass.this){}

锁的申请和开释

锁的申请和开释都是在应用 synchronized 关键字时依据外部的底层的申请开释协定来应用的。所有的锁都是块构造，当进入 synchronized 办法时失去锁，退出时开释锁。
锁操作基于”每个线程”而不是“每次调用”。
synchronized 和原子操作（atomic）不是等价的。然而同步能够实现原子操作。
如果一个线程开释了锁，那么其余线程能够失去它，然而无奈保障线程在什么时候失去锁，这里 没有偏心 可言。
JVM 在类加载和初始化的时候为 Class 类主动申请和开释锁。

齐全同步对象

锁是最根本的信息接管管制机制。如果，S 客户想要调用一个对象的办法，而另一个办法或者代码块正在执行，那么锁能够阻塞 S 用户。

原子对象

基于锁的最平安并发面向对象设计策略是，把注意力限度在 齐全同步 中：

• 所有办法都是同步的
• 没有公共的成员变量，或者其余封装问题
• 所有办法都是无限的，（不存在无休止的递归和无线循环），所有操作最终会开释锁
• 所有成员变量在构造函数中曾经初始化为稳固统一的状态

• 在一个办法开始和完结的是，对象状态都应该稳固统一，即便出错也应该如此

  死锁

  例如

  public static void main(String[] args) {Resource1 resource1 = new Resource1("resource1");
        Resource1 resource2 = new Resource1("resource2");
        Thread t1 = new Thread(() ->{for (int i = 0; i < 100; i++) {resource1.saveResource(resource2);
            }
        });
        Thread t2 = new Thread(() ->{for (int i = 0; i < 100; i++) {resource2.saveResource(resource1);
            }
        });
        t1.start();
        t2.start();}

上述代码在执行过程中就会产生死锁。
死锁：就是在两个线程或者多个线程都有权拜访两个对象或者多个对象，并且线程都在曾经失去一个锁的状况下期待其余线程开释锁。

程序化资源

为了防止死活锁者其余活跃性失败，咱们须要其余_独占技术_，例如程序化资源。

程序化资源：

是把每一个嵌套的 synchronized 办法或者代码块中应用的对象和数字标签关联起来。如果同步操作是依据对象标签的大小顺序排列，那么死锁就不会产生。
线程 A 获取了 1 的同步锁正在期待 2 的同步锁，依照初始化程序就能够防止死锁产生。例如：

public class ApplyLock {private List<Object> listOf = new ArrayList<>();

    public synchronized boolean applyLock(Resource resource1,Resource resource2){if (listOf.contains(resource1) || listOf.contains(resource2)){return false;} else {
// 依照程序初始化资源
            listOf.add(resource1);
            listOf.add(resource2);
            return true;
        }
    }

    public synchronized void freeListOf(Resource resource1,Resource resource2){listOf.remove(resource1);
        listOf.remove(resource2);
    }
}

咱们能够应用 System.identityHashCode()的返回值。即便类自身曾经笼罩了 hashCode 办法，然而 System.identityHashCode()还是会间接调用 hashCode。咱们无奈保障 System.identityHashCode()的返回值的唯一性，但在理论运行的零碎中，这个办法的唯一性在很大水平上失去了保障。
例如：

public synchronized boolean applyLock(Resource resource1,Resource resource2){if (listOf.contains(resource1) || listOf.contains(resource2)){return false;}else if (System.identityHashCode(resource1) < System.identityHashCode(resource2)) { // 放弃程序性
            return true;
        }
//        else {// 放弃程序性
//            listOf.add(resource1);
//            listOf.add(resource2);
//            return true;
//        }
        return false;
    }

    public synchronized void freeListOf(Resource resource1,Resource resource2){listOf.remove(resource1);
        listOf.remove(resource2);
    }

Java 存储模型

依照程序执行

final class SetCheck{
    private int a=0;
    private long b=0;
    void set(){
        a = 1;
        b = -1;
    }
    boolean check(){return ((b == 0)||(b ==-1 && a == 1))
    }
}

在纯串行化的语言里，check 办法永远不会返回 false。
在并发环境下，就会有齐全不同的后果。一个线程在调用 set，另一个线程在调用 check，那么很有可能导致最初的后果为 false。check 的执行可能会被优化执行的 set 打断。这是就会产生 check 返回 false 的状况。
在并发编程中，不仅仅能够有多条语句穿插执行，而且能够打乱程序执行，或者被优化后执行。
咱们在设计编写多线程程序时，必须应用同步来防止因为优化而引发的复杂性。
模型只定义线程和住存的形象关系，每一个线程都有一个工作存储空间（缓存或寄存器的形象）用来存储数据。模型保障了与办法相干的指令程序以及与数据相干的存储单元这两者之间的一些交互的个性。很多规定都是依据何时主存和每线程工作存储空间之间传送数据来形容的，次要围绕一下三个问题

1. 原子性（Atomicity）。指令必须有不可分割性。为了建模的目标，规定只须要论述对代表成员变量的存储单元的简略读写操作。这里的成员变量能够使实例对象和动态变量，包含数据，然而不蕴含办法中的局部变量
2. 可见性（Visbility）。在什么状况下一个线程的成果对另一个线程是可见的。这里的成果是指写入成员变量的值对于这个成员变量的读操作是可见的。

3. 程序化（Ordering）。在什么状况下对一个线程的操作是能够容许无序的。次要的程序化问题围绕着读写无关的赋值语句的程序。

   原子性

   原子性保障咱们获取到的值是初始值或者被某些线程批改后的值，绝不是通过多个线程同时批改而失去的凌乱的数据。然而咱们要晓得，_原子性自身并不能保障程序取得的值是线程最近批改的值_。因为这个起因，原子性实质上对并发的程序的设计没有多大影响。分布式系统中咱们个别要求最终一致性。

   可见性

   只有在下列的状况中，线程对数据的批改对于另一个线程而言才是可见的：

4. 写线程开释了锁，读线程获取到了该同步锁

   1. 在开释锁的时候要把线程所应用的工作存储单元的值刷新到主内存中，取得锁的时候要核心加载可拜访的成员变量的值。锁只为同步办法或者中的其余操作提供 独占 意义。
   2. 同步具备双重意义：_它既通过锁反对高层同步协定，同时也反对存储系统，从而保障多个线程中的数据同步_。绝对于串行编程来说，分布式编程和并发编程更具备相似性。synchronized 的第二个意义在于，_使得一个线程中的办法能够发送或者接管另一个线程办法中对于共享数据的批改信息。从这个角度来看，应用锁和发消息只是说法不同_。
5. 如果一个成员变量被申明为 volatile, 那么在写线程操作存储之前，写入这个 volatile 成员变量的数据在主存中刷新，并使其对其余线程可见。读线程在每次应用 volatile 变量之前都要从新读入数据。
6. 当一个线程拜访一个对象的成员比那里，那么线程获取的值不是初始值就是被其余线程批改过的值

7. 当一个线程操作完结，所有的写入数据都要被刷新到主内存中

   1. 例如，线程 A 应用 Thread.join 办法和线程 B 完结同步，那么线程 A 必定能够看到线程 B 的执行后果
      2. 在同一个线程内的不同办法之间传递对象的援用，永远不会引起可见性问题

   volatile

   在原子性，可见性以及排序方面，把一个数据申明为 volatile 简直等价于应用一个小的 synchronized 润饰的 get，set 办法：

   class VFloat{
    private float v;
    synchronized void set(float f){v = f}
    synchronized void get(){return v}
   }

   然而，须要留神的是，对于合乎的读写操作，volatile 并不能保障其原子性，例如：i++ 操作