Thead.sleep & synchronized

实战分析

一直都说，Threed.sleep是不会释放锁，而wait是释放锁的(对象锁)，现理论上来分析一下啊。

由于CPU分配的每个线程的时间片极为短暂(一般为几十毫秒)，所以，CPU通过不停地切换线程执行，这样就给程序员一种错觉，以为多个线程是在同时执行。sleep就是正在执行的线程主动让出CPU，CPU去执行其他线程，在sleep指定的时间过后，CPU才会回到这个线程上继续往下执行，如果当前线程进入了同步锁，sleep方法并不会释放锁，即使当前线程使用sleep方法让出了CPU，但其他被同步锁挡住了的线程也无法得到执行。

1）Testcase

多线程A、B同时进行。Method A 与 B都带有同步锁.

public class SampleTest implements Runnable {

    private int number = 10;

    private synchronized void firstMethod() {
        System.out.println("Method A");
        number += 100;
        System.out.println("+100-     " + number);
    }

    private synchronized void secondMethod() throws Exception {
        System.out.println("Method B ready to sleep");
         // 休息0.2S，阻塞队列,验证当前对象的机制锁被占用时，是否可以访问其他同步代码块
        Thread.sleep(2000);
        //this.wait(20000);
        /**
         * 使用notifyAll、wait、notify方法 需要添加锁.
         */
        System.out.println("wake up");
        number *= 200;
        System.out.println("*=200      -" + number);
    }

    @Override
    public void run() {
        System.out.println("Thread running");
        firstMethod();
    }

    public static void main(String[] args) throws Exception {
        SampleTest sampleTest = new SampleTest();
        Thread thread = new Thread(sampleTest);
        thread.start(); // 执行run里面的代码.
        System.out.println("prepare run second method");
        sampleTest.secondMethod();
    }
}

1.1）Testcase Res

***解释：主线程先启动，但创建线程等的资源消耗，所以主线程会先执行SecondMethod. 加了synchronized修饰的方法必须得到锁才能运行。当Method B休眠2S之后，wake up之后还抱有锁，因此直接run 剩下的方法。

2)Testcase

Method A 不带锁，Method B sleep 2S.

private  void firstMethod() {
System.out.println("Method A");
number += 100;
System.out.println("+100-     " + number);
}

2.1) Testcase Res

解释：主线程休眠后，没有释放锁，但线程A中的方法并不需要锁，因此先+100.

3)Testcae

private synchronized void firstMethod() {
  System.out.println("Method A");
  number += 100;
  System.out.println("+100-     " + number);
}

private  synchronized void secondMethod() throws Exception {
  System.out.println("Method B ready to sleep");
  // 休息0.2S，阻塞队列,验证当前对象的机制锁被占用时，是否可以访问其他同步代码块
  //Thread.sleep(2000);
  this.wait(2000);
}

-->连带责任

如果在非同步控制方法里调用java.util.concurrent.locks.Condition中的await()和signalAll()或者Object中的wait()，notify()和notifyAll()方法，程序能通过编译，但运行的时候，将得IllegalMonitorStateException异常。

所以使用Object.wait() 必须加上synchronized

3.1)Res

结论：wait()会释放锁，这样加锁的方法可以争夺这把锁.

4、Thread.sleep(1000)，1000ms后是否立即执行？

不一定，在未来的1000毫秒内，线程不想再参与到CPU竞争。那么1000毫秒过去之后，这时候也许另外一个线程正在使用CPU，那么这时候操作系统是不会重新分配CPU的，直到那个线程挂起或结束；况且，即使这个时候恰巧轮到操作系统进行CPU 分配，那么当前线程也不一定就是总优先级最高的那个，CPU还是可能被其他线程抢占去。

5、Thread.sleep(0)，是否有用？

休眠0ms，这样的休眠有何意义？Thread.Sleep(0)的作用，就是“触发操作系统立刻重新进行一次CPU竞争，重新计算优先级”。竞争的结果也许是当前线程仍然获得CPU控制权，也许会换成别的线程获得CPU控制权。这也是我们在大循环里面经常会写一句Thread.sleep(0) ，因为这样就给了其他线程比如Paint线程获得CPU控制权的权力，这样界面就不会假死在那里。

6、Thread.sleep()的替代品

sleep（里面的参数不太容易理解）

使用timeUnit.MINUTES.sleep(4L) 可以使程序更加易懂，但底层还是调用的Thread.sleep()方法。

synchronous

前言：

Synchronized关键字解决的是多个线程之间访问资源的同步性，synchronized关键字可以保证被它修饰的方法或者代码块在任意时刻只能有一个线程执行。

但这是一个重量级的锁！！

synchronized是Java中的关键字，是一种同步锁。它修饰的对象有以下几种：

　　1. 修饰一个代码块，被修饰的代码块称为同步语句块，其作用的范围是大括号{}括起来的代码，作用的对象是调用这个代码块的对象；
　　2. 修饰一个方法，被修饰的方法称为同步方法，其作用的范围是整个方法，作用的对象是调用这个方法的对象；
　　3. 修改一个静态的方法，其作用的范围是整个静态方法，作用的对象是这个类的所有对象；
　　4. 修改一个类，其作用的范围是synchronized后面括号括起来的部分，作用主的对象是这个类的所有对象。

注意事项：

synchronized关键字不能被继承。如果在父类中的某个方法使用了synchronized关键字，而在子类中覆盖了这个方法，在子类中的这个方法默认情况下并不是同步的，而必须显式地在子类的这个方法中加上synchronized关键字才可以

.总结

synchronized关键字用在普通方法上只对当前的对象的这个方法有同步作用。且当一个线程执行同步方法时，其他线程不可访问该对象的其他同步方法，但是可以访问不同步的方法。
synchronized关键字用在static方法上对任何实例化这个类的对象均有效。但是不影响对象锁方法的执行