内置锁

    java提供了一种内置的锁机制来支持原子性:同步代码块（Synchronized Block），同步代码块包括了两部分：一个作为锁的对象引用，一个作为由这个锁所保护的代码块。以关键字syschronzied来修饰的方法就是一种横跨整个方法体的同步代码块，其中该同步代码块的锁就是方法调用所在的对象。静态的synchronzied方法以Class对象作为锁。

    每个Java对象都可以用作一个实现同步的锁，这些锁被称为内置锁（Intrinsic Lock）或监视器锁(Monitor lock)，线程在进入同步代码块之前会自动获得锁，并且在退出同步代码块时自动释放锁（无论是正常退出或者异常退出）。获得内置锁的唯一途径就是进入由这个锁保护的同步代码块或方法。

     Java内置锁相当于一种互斥体，就是说最多只有一个线程的同步代码块会以原子方式执行，多个线程在执行该代码块时也不会相互干扰。这种方式会有一个弊端就是访问该方法的性能不会很好，阻塞的太严重了。看其中的的service1(）方法。

package com.zy.test;

import java.util.concurrent.atomic.AtomicLong;

public class CountingFactorizer {
    
    private final AtomicLong count = new AtomicLong(0);
    
    private long countOld = 0;
    
    public long getCount() {
        return count.get();
    }
    
    public void service() {
        count.incrementAndGet();
        System.out.println("递增是原子操作：" + count.get());// 打印结果会不准确，原因在于并没有把打印操作封装进复合操作中
    }
    
    public synchronized void service1() {
        countOld++;
        System.out.println("递增+打印都是原子操作:" + countOld);// 打印结果会准确，因为整个方法所代表的操作已经是原子性的了
    }
    
    
    public static void main(String[] args) {
        CountingFactorizer countingFactorizer = new CountingFactorizer();
        RequestDemo1 requestDemo = new RequestDemo1(countingFactorizer);
        for (int i = 0; i < 20; i++) {
            Thread thread = new Thread(requestDemo);
            thread.start();
        }
    }

}


class RequestDemo1 implements Runnable {
    CountingFactorizer countingFactorizer;
    RequestDemo1(CountingFactorizer countingFactorizer) {
        this.countingFactorizer = countingFactorizer;
    }

    @Override
    public void run() {
        countingFactorizer.service();
        countingFactorizer.service1();
    }
}