java 的Thread的同步代码块synchronized(){}放在while里面跟外面有区别

2019独角兽企业重金招聘Python工程师标准>>>

java代码:

package myTest;

public class TestThread extends Thread{
	
	private Integer ticketNum = 10;
	
	public void run() {
		synchronized (this) {//这个同步代码块和下面的while调换位置会有完全不同的结果
			while(true) {
				if(this.ticketNum > 0) {
					try {
						System.out.println(Thread.currentThread().getName()+":"+this.ticketNum);
						this.ticketNum --;
						Thread.sleep(100);
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
				}else{
                    break;
                }
			}
		}
	}
	
	public static void main(String[] args) {
		TestThread t = new TestThread();//这么写才能保证锁住的this是同一个实例对象
		new Thread(t, "t1").start();
		new Thread(t, "t2").start();
        /* 下面这种写法,每个线程都是不同的一个新的ThreadTest的实例对象,锁住的this分别是不同的对象,所以互不阻塞
          ThreadTest t = new ThreadTest();
		  t.setName("t1");
		  t.start();
		  ThreadTest t2 = new ThreadTest();
		  t2.setName("t2");
		  t2.start();
		  ThreadTest t3 = new ThreadTest();
		  t3.setName("t3");
		  t3.start();
        */
	}
}

解析:

（1）写在while外面的时候：t1,t2任意一个线程先拿到执行权的话就会一直是它在循环了。因为没有能停下来的语句，别的线程也执行不了，因为synchronized(){}是锁的。只有该线程循环完出来的时候，synchronized(){}才是打开的。这时候就不能满足t1，t2随机进入while循环;此时synchronized(){}锁住的是整个代码块,而同步代码中的sleep()是不会释放锁的,会继续执行sleep()后面的代码,继续执行所以t1和t2谁拿到锁就会一直执行,直到while跳出(如果改为this.wait(),则会释放锁,此时t1,t2谁拿到锁,谁就会进入同步代码块)

（2）如果写在while里面就不同了，这二个线程不论是谁得到cpu执行权都会先进入while循环，然后判断synchronized(){}是否是锁的，如果不是就可以卖出一张票，如果是就等待别的线程先执行完。例如t2拿到锁,正在执行同步代码块,此时t1进入while里面,因为t2拿到锁,所以t1要等待t2执行完,当t2执行完同步代码块之后,会再次进入while的下一个循环,此时和t1和t2会竞争锁,拿到锁的会进入同步代码块,此时不会出现只有一个窗口卖票的情况,而是都在卖票...

（3）简单拿模拟窗口卖票来说，我们看到的执行效果的区别就是:
            A：锁在while外面的时候，运行程序，不管有多少个窗口也总是一个窗口在卖票，从头卖到尾绝对永远都是先进入循环的那个线程会把所有票卖完

            B：锁在while循环里面的时候，会是随机的一个窗口在卖，如果是二个线程的话，就应该是二个窗口都有在卖。

 

java多线程什么时候释放锁—wait（）、notify（）

 https://www.cnblogs.com/hy928302776/p/3255641.html

 由于等待一个锁定线程只有在获得这把锁之后，才能恢复运行，所以让持有锁的线程在不需要锁的时候及时释放锁是很重要的。

在以下情况下，持有锁的线程会释放锁：
    1. 执行完同步代码块。
    2. 在执行同步代码块的过程中，遇到异常而导致线程终止。
    3. 在执行同步代码块的过程中，执行了锁所属对象的wait()方法，这个线程会释放锁，进行对象的等待池。
   

除了以上情况外，只要持有锁的此案吃还没有执行完同步代码块，就不会释放锁。

因此在以下情况下，线程不会释放锁：
    1. 在执行同步代码块的过程中，执行了Thread.sleep()方法，当前线程放弃CPU，开始睡眠，在睡眠中不会释放锁。该方法调用时，可以看到线程明显有被阻塞。但是设定一过，就自己开始继续执行。可以说明sleep方法会让线程阻塞，但是并没有放弃自己所持有的锁，阻塞完毕后，它任然持有锁，可以接着执行之前阻塞之后的任务。
    2. 在执行同步代码块的过程中，执行了Thread.yield()方法，当前线程放弃CPU，但不会释放锁。
    3. 在执行同步代码块的过程中，其他线程执行了当前对象的suspend()方法，当前线程被暂停，但不会释放锁。但Thread类的suspend()方法已经被废弃。
    避免死锁的一个通用的经验法则是：当几个线程都要访问共享资源A、B和C时，保证使每个线程都按照同样的顺序去访问他们，比如都先访问A，再访问B和C。
    java.lang.Object类中提供了两个用于线程通信的方法：wait()和notify()。需要注意到是，wait()方法必须放在一个循环中，因为在多线程环境中，共享对象的状态随时可能改变。当一个在对象等待池中的线程被唤醒后，并不一定立即恢复运行，等到这个线程获得了锁及CPU才能继续运行，又可能此时对象的状态已经发生了变化。

    # 调用obj的wait(), notify()方法前，必须获得obj锁，也就是必须写在synchronized(obj) {...} 代码段内。
　　
　# 调用obj.wait()后，线程A就释放了obj的锁，否则线程B无法获得obj锁，也就无法在synchronized(obj) {...} 代码段内唤醒A。
　　
　# 当obj.wait()方法返回后，线程A需要再次获得obj锁，才能继续执行。
　　
　# 如果A1,A2,A3都在obj.wait()，则B调用obj.notify()只能唤醒A1,A2,A3中的一个（具体哪一个由JVM决定）。
　　
　# obj.notifyAll()则能全部唤醒A1,A2,A3，但是要继续执行obj.wait()的下一条语句，必须获得obj锁，

因此，A1,A2,A3只有一个有机会获得锁继续执行，例如A1，其余的需要等待A1释放obj锁之后才能继续执行。
　　
　　# 当B调用obj.notify/notifyAll的时候，B正持有obj锁，因此，A1,A2,A3虽被唤醒，但是仍无法获得obj锁。直到B退出synchronized块，释放obj锁后，A1,A2,A3中的一个才有机会获得锁继续执行。
　　
　　wait()/sleep()的区别
　　
　　前面讲了wait/notify机制，Thread还有一个sleep()静态方法，它也能使线程暂停一段时间。sleep与wait的不同点是：sleep并不释放锁，并且sleep的暂停和wait暂停是不一样的。obj.wait会使线程进入obj对象的等待集合中并等待唤醒。
　　
　　但是wait()和sleep()都可以通过interrupt()方法打断线程的暂停状态，从而使线程立刻抛出InterruptedException。
　　
　　如果线程A希望立即结束线程B，则可以对线程B对应的Thread实例调用interrupt方法。如果此刻线程B正在wait/sleep/join，则线程B会立刻抛出InterruptedException，在catch() {} 中直接return即可安全地结束线程。
　　
　　需要注意的是，InterruptedException是线程自己从内部抛出的，并不是interrupt()方法抛出的。对某一线程调用interrupt()时，如果该线程正在执行普通的代码，那么该线程根本就不会抛出InterruptedException。但是，一旦该线程进入到wait()/sleep()/join()后，就会立刻抛出InterruptedException。

转载于:https://my.oschina.net/u/2331760/blog/3021474