学习Java多线程的一些思考

学习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