转载

synchronized的使用（一）

在现代计算机中往往存在多个 CPU 核心，而 1 个 CPU 能同时运行一个线程，为了充分利用 CPU 多核心，提高 CPU 的效率，多线程就应时而生了。

那么多线程就一定比单线程快吗？答案是不一定，因为多线程存在单线程没有的问题

上下文切换 ：线程从 运行状态 切换到 阻塞状态 或者 等待状态 的时候需要将线程的运行状态保存，线程从 阻塞状态 或者 等待状态 切换到 运行状态 的时候需要加载线程上次运行的状态。线程的运行状态从保存到再加载就是一次上下文切换，而上下文切换的开销是非常大的，而我们知道 CPU 给每个线程分配的时间片很短，通常是几十毫秒(ms)，那么线程的切换就会很频繁。
死锁：死锁的一般场景是，线程 A 和线程 B 都在互相等待对方释放锁，死锁会造成系统不可用。
资源限制的挑战 ：资源限制指计算机硬件资源或软件资源限制了多线程的运行速度，例如某个资源的下载速度是 1Mb/s ，资源的服务器带宽只有 2Mb/s ，那么开 10 个线程下载资源并不会将下载速度提升到 10Mb/s 。

既然多线程存在这些问题，那么我们在开发的过程中有必要使用多线程吗？我们知道任何技术都有它存在的理由，总而言之就是多线程利大于弊，只要我们合理使用多线程就能达到事半功倍的效果。

多线程的意思就是多个线程同时工作，那么多线程之间如何协同合作，这也就是我们需要解决的 线程通信 、 线程同步 问题

线程通信 ：线程通信指线程之间以何种机制来交换消息，线程之间的通信机制有两种： 共享内存 和 消息传递 。共享内存即线程通过对共享变量的读写而达到隐式通信，消息传递即线程通过发送消息给对方显示的进行通信。
线程同步 ：线程同步指不同线程对同一个资源进行操作时候线程应该以什么顺序去操作，线程同步依赖于线程通信，以共享内存方式进行线程通信的线程同步是显式的，以消息传递方式进行线程通信的线程同步是隐式的。

synchronized简介

synchronized 是Java的关键字，可用于同步实例方法、类方法(静态方法)、代码块

同步实例方法 ：当 synchronized 修饰实例方法的时候，同步的范围是当前实例的实例方法。
同步类方法 ：当 synchronized 修饰类方法的时候，同步的范围是当前类的方法。
同步代码块 ：当 synchronized 修饰代码块的时候，同步的范围是 () 中的对象。

"talk is cheap show me the code" 让我们分别运行个例子来看看。

同步实例方法

synchronized public void synSay() {
    System.out.println("synSay----" + Thread.currentThread().getName());
    while (true) { //保证进入该方法的线程 一直占用着该同步方法

    }
}

public void say() {
    System.out.println("say----" + Thread.currentThread().getName());
}
public static void main(String[] args){
    Test test1 = new Test();
    Thread t1 = new Thread(new Runnable() {
        @Override
        public void run() {
            test1.synSay();
        }
    });

    Thread t2 = new Thread(new Runnable() {
        @Override
        public void run() {
            try {
                Thread.sleep(3000);  //休眠3秒钟 保证线程t1先执行
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            test1.say();
            test1.synSay();
        }
    });

    t1.start();
    t2.start();
}

运行输出

synSay----Thread-0  //线程t1
say----Thread-1  //线程t2

创建 t1 ， t2 两个线程，分别执行同一个实例 test1 的方法，线程 t1 先执行加了同步关键字的 synSay 方法，注意方法里面需要加上个 while 死循环，目的是让线程一直在同步方法里面，然后然线程t1执行之后再让线程t2去执行，此时线程t2并不能成功进入到 synSay 方法里面，因为此时线程t1正在方法里面，线程2只能在 synSay 方法外面阻塞，但是线程t2可以进入到没有加同步关键字的 say 方法。

也就是说关键字 synchronized 修饰实例方法的时候，锁住的是该实例的加了同步关键字的方法，而没有加同步关键字的方法，线程还是可以正常访问的。但是不同实例之间同步是不会影响的，因为每个实例都有自己的一个锁，不同实例之间的锁是不一样的。

同步类方法

synchronized static public void synSay() {
    System.out.println("static synSay----" + Thread.currentThread().getName());
    while (true) { //保证进入该方法的线程 一直占用着该同步方法

    }
}

synchronized public void synSay1() {
    System.out.println("synSay1----" + Thread.currentThread().getName());
}

public void say() {
    System.out.println("say----" + Thread.currentThread().getName());
}
public static void main(String[] args){
    Test test1 = new Test();
    Test test2 = new Test();
    Thread t1 = new Thread(new Runnable() {
        @Override
        public void run() {
            test1.synSay();
        }
    });

    Thread t2 = new Thread(new Runnable() {
        @Override
        public void run() {
            try {
                Thread.sleep(3000);  //休眠3秒钟 保证线程t1先执行
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            test1.say();
            test2.say();
            test1.synSay();
        }
    });

    t1.start();
    t2.start();
}

运行输出

static synSay----Thread-0 //线程t1 实例test1
say----Thread-1 //线程t2 实例test1
say----Thread-1 //线程t2 实例test2

static synSay----Thread-0 //线程t1 实例test1
say----Thread-1  //线程t2 实例test1
synSay1----Thread-1 //线程t2 实例test1
say----Thread-1 //线程t2 实例test2

这里和上面的同步实例方法的代码差不多，就是将 synSay 方法加上了 static 修饰符，即把方法从实例方法变成类方法了，然后我们再新建个实例 test2 ，先让线程t1调用实例test1的synSay类方法，在让线程t2去调用实例test1的say实例方法、synSay类方法和让线程t2去调用实例test2的say实例方法，发现在线程t1占用加了同步关键字的 synSay 类方法的时候，别的线程是不能调用加了锁的类方法的，但是可以调用没有加同步关键字的方法或者加了同步关键字的实例方法，也就是说每个类有且仅有1 1 个锁，每个实例有且仅有 1 个锁，但是每个类可以有一个或者多个实例，类的锁和实例的锁不会相互影响，实例之间的锁也不会相互影响。需要注意的是，一个类和一个实例有且仅有一个锁，当这个锁被其他线程占用了，那么别的线程就无法获得锁，只有阻塞等待。

synchronized的使用（一）

同步代码块

    public void synSay() {
        String x = "";
        System.out.println("come in synSay----" + Thread.currentThread().getName());
        synchronized (x) {
            System.out.println("come in synchronized----" + Thread.currentThread().getName());
            while (true) { //保证进入该方法的线程 一直占用着该同步方法

            }
        }
    }
public static void main(String[] args){
        Test test1 = new Test();
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                test1.synSay();
            }
        });

        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    Thread.sleep(3000);  //休眠3秒钟 保证线程t1先执行
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                test1.synSay();
            }
        });

        t1.start();
        t2.start();
}

运行输出

come in synSay----Thread-0
come in synchronized----Thread-0
come in synSay----Thread-1

可以发现同步代码块和同步实例方法、同步类方法其实差不多，但是同步代码块将同步的范围缩小了，可以同步到指定的对象上，而不像同步实例方法、同步类方法那样同步的是整个方法，所以 同步代码块 在效率上比其他两者都有较大的提升。

需要注意的是，当同步代码块的时候，在 类方法 中加入同步代码块且同步的对象是 xx.class 等类的引用的时候，同步的是该类，如果在 **实例方法中加入同步代码块且同步的对象是 this ，那么同步的是该实例，可以看成前者使用的是 类的锁 ，后者使用的是 实例的锁 。