黑马程序员技术交流社区

标题: 同步部分锁的验证 [打印本页]
作者: 姬光普    时间: 2015-5-20 23:47
标题: 同步部分锁的验证
看了视频后，对同步安全锁的验证，这是老师视频上举得例子
1.同步代码块中的锁就是一个简单的对象，很具有随意性
代码：
  1. class Test implements Runnable
  2. {
  3.         private int tick = 100;
  4.         Object obj = new Object();
  5.         public void run()
  6.         {
  7.                 while(tick > 0)
  8.                 {
  9.                         synchronized(obj)
  10.                         {
  11.                                 if(tick > 0)
  12.                                 {
  13.                                         try
  14.                                         {
  15.                                                 Thread.sleep(1);
  16.                                         }
  17.                                         catch(Exception e)
  18.                                         {

  20.                                         }
  21.                                         System.out.println(Thread.currentThread().getName()+"...sale..."+tick--);
  22.                                 }
  23.                         }
  24.                 }
  25.         }
  26. }

  28. public class Test1
  29. {
  30.         public static void main(String[] args)
  31.         {
  32.                 Test t = new Test();
  33.                 Thread d1 = new Thread(t);
  34.                 Thread d2 = new Thread(t);
  35.                 Thread d3 = new Thread(t);
  36.                 Thread d4 = new Thread(t);
  37.                 d1.start();
  38.                 d2.start();
  39.                 d3.start();
  40.                 d4.start();
  41.         }
  42. }
复制代码
2.同步函数中的锁是this，下面代码中
代码：
  1. package org.heima1;
  2. public class Test2 {
  3.         /**
  4.          * 验证同步函数的锁是不是this，利用同步代码块和同步函数两种方式同步进行。如果是this，则遵从了同步的前提：必须是多个线程使用同一个锁，不会输出0
  5.          */
  6.         public static void main(String[] args) {
  7.                 Tickets t=new Tickets();
  8.                 Thread t1=new Thread(t);
  9.                 Thread t2=new Thread(t);
  10.                 t1.start();
  11.                 try {
  12.                         Thread.sleep(10);//停一下主线程
  13.                 } catch (InterruptedException e) {
  14.                         e.printStackTrace();
  15.                 }
  16.                 t.flag=false;
  17.                 t2.start();
  18.         }
  19. }
  20. class Tickets implements Runnable{
  21.         private int num=1000;//总共1000张票
  22.         Object obj=new Object();
  23.         Boolean flag=true;
  24.         public void run(){
  25.                 if(flag){
  26.                         while(true){
  27.                                 //synchronized(obj){//如果用obj则两个线程不是共用一个锁，产生安全问题，直接导致输出0
  28.                                 synchronized(this){//如果用this锁，则没有输出0，表示两者用的是同一个锁
  29.                                         if(num>0){
  30.                                                 try{
  31.                                                         Thread.sleep(10);
  32.                                                 }catch(Exception e){
  33.                                                 }
  34.                                                 System.out.println(Thread.currentThread().getName()+"---代码块----第"+num--);
  35.                                         }
  36.                                 }
  37.                                
  38.                         }               
  39.                 }
  40.                 else {
  41.                         while(true)
  42.                                 show();
  43.                 }
  44.         }
  45.         public synchronized void show(){  //同步函数
  46.                 if(num>0){
  47.                         try{
  48.                                 Thread.sleep(10);
  49.                         }catch(Exception e){
  50.                         }
  51.                         System.out.println(Thread.currentThread().getName()+"----同步函数----第"+num--);
  52.                 }
  53.         }
  54. }
复制代码
3.静态同步函数使用的锁是该方法所在类的字节码对象，也就是类名.class
代码示例：
  1. public class Test3 {

  3.         /**
  4.          * 验证静态同步函数的锁是不是所在类的字节码对象，利用同步代码块和同步函数两种方式同步进行。
  5.          */
  6.         public static void main(String[] args) {
  7.                 Tickets2 t=new Tickets2();
  8.                 Thread t1=new Thread(t);
  9.                 Thread t2=new Thread(t);
  10.                 t1.start();
  11.                 try {
  12.                         Thread.sleep(10);//停一下主线程
  13.                 } catch (InterruptedException e) {
  14.                         e.printStackTrace();
  15.                 }
  16.                 t.flag=false;
  17.                 t2.start();

  19.         }

  21. }
  22. class Tickets2 implements Runnable{
  23.         private static int num=100;//总共1000张票
  24.         Object obj=new Object();
  25.         Boolean flag=true;
  26.        
  27.         public void run(){
  28.                 if(flag){
  29.                         while(true){
  30.                                 //synchronized(obj){//如果用obj则两个线程不是共用一个锁，产生安全问题，直接导致输出0
  31.                                 //synchronized(this){//如果用this则两个线程不是共用一个锁，产生安全问题，直接导致输出0
  32.                                 synchronized(Tickets2.class){//如果用Tickets2.class锁，则没有输出0，表示两者用的是同一个锁
  33.                                         if(num>0){
  34.                                                 try{
  35.                                                         Thread.sleep(10);
  36.                                                 }catch(Exception e){
  37.                                                 }
  38.                                                 System.out.println(Thread.currentThread().getName()+"---代码块----第"+num--);
  39.                                         }
  40.                                 }
  41.                                
  42.                         }               
  43.                 }
  44.                 else {
  45.                         while(true)
  46.                                 show();
  47.                 }
  48.         }
  49.         public static synchronized void show(){  //同步函数
  50.                 if(num>0){
  51.                         try{
  52.                                 Thread.sleep(10);
  53.                         }catch(Exception e){
  54.                         }
  55.                         System.out.println(Thread.currentThread().getName()+"----同步函数----第"+num--);
  56.                 }
  57.         }
  58. }
复制代码






欢迎光临 黑马程序员技术交流社区 (http://bbs.itheima.com/) 黑马程序员IT技术论坛 X3.2