java同步和互斥【用具体程序说明】

2022-11-10 07:29:15

java同步和互斥【用具体程序说明】

 
         所有对象都自动含有单一的锁，也就是所有对象都有且只有唯一的锁，所以当某个任务（线程）访问一个类A中含有sycnhronized的方法是，那么在这个线程从该方法返回之前（也就是该方法在当前线程执行完之前），类A中的其他被该关键字标记的方法在其他的线程中都会被阻塞。
            通俗点说就是，当调用A的含有synchronized的方法是，A会被枷锁，此时A中其他含有synchronized方法只有等到前一个方法调用完毕释放了锁才能被调用

具体说明见另一篇博客<<java同步和互斥【相关原理】》

下面看看具体的程序，其中，Timer中的字段num是共享资源

  1. package com.bankht.synchronize;
  2. public class TestSync implements Runnable {
  3. Timer timer = new Timer();
  4. public static void main(String[] args) {
  5. TestSync test = new TestSync();
  6. Thread t1 = new Thread(test);
  7. Thread t2 = new Thread(test);
  8. t1.setName("t1");
  9. t2.setName("t2");
  10. t1.start();
  11. t2.start();
  12. }
  13. public void run() {
  14. timer.add(Thread.currentThread().getName());
  15. }
  16. }
  17. class Timer {
  18. private static int num = 0;
  19. public void add(String name) {
  20. num++;
  21. try {
  22. Thread.sleep(1);
  23. } catch (InterruptedException e) {
  24. }
  25. System.out.println(name + ", 你是第" + num + "个使用timer的线程");
  26. }
  27. }
  1. 由于没有同步，所以运行结果如下所示

t1, 你是第2个使用timer的线程

t2, 你是第2个使用timer的线程

也就是说当线程一运行到num++的时候被打线程2打断了，由于java中递增和递减操作均不是原子操作，所以本程序中即使没有调用sleep，也会出现这种被打断的情况

下面看看同步的效果

  1. public void add(String name) {
  2. synchronized (this) {//同步
  3. num++;
  4. try {
  5. Thread.sleep(1000);
  6. } catch (InterruptedException e) {
  7. }
  8. System.out.println(name + ", 你是第" + num + "个使用timer的线程");
  9. }
  10. }

这样运行结果就会出是正确的

t1, 你是第1个使用timer的线程

t2, 你是第2个使用timer的线程

但是，下面为了说明问题把TestSync里面的run方法改成如下所示

  1. public void run() {
  2. /
  3. time.add(Thread.currentThread().getName());
  4. try {
  5. Thread.sleep(1000);//为了显示结果，让其睡眠一秒
  6. } catch (InterruptedException ex) {
  7. Logger.getLogger(TestSync.class.getName()).log(Level.SEVERE, null, ex);
  8. }
  9. System.out.println(Thread.currentThread().getName() + "----");
  10. }

那么在此运行就是

t1, 你是第1个使用timer的线程

t2, 你是第2个使用timer的线程

t1--------

t2--------

而不是你所想象的

t1, 你是第1个使用timer的线程
t1----
t2, 你是第2个使用timer的线程
t2----

原因就是在线程t1在睡眠的时候，线程t2切换进来，执行了一次，怎样得到正确的结果呢，下面把TestSync里面的run方法做如下改进就可以得到上面预期的结果

  1. public void run() {
  2. synchronized(time){
  3. time.add(Thread.currentThread().getName());
  4. try {
  5. Thread.sleep(3000);
  6. } catch (InterruptedException ex) {
  7. Logger.getLogger(TestSync.class.getName()).log(Level.SEVERE, null, ex);
  8. }
  9. System.out.println(Thread.currentThread().getName() + "----");
  10. }
  11. }

因为t1先获得time的锁，所以在执行完run里面的同步块之前，即使sleep()，t2也不会执行，因为t2没有获得time的锁，且sleep(）操作也不释放锁（这也是和wait的巨大区别）

附录：TestSync.java全部代码

  1. package com.bankht.synchronize;
  2. import java.util.logging.Level;
  3. import java.util.logging.Logger;
  4. public class TestSync implements Runnable {
  5. Timer timer = new Timer();
  6. public static void main(String[] args) {
  7. TestSync test = new TestSync();
  8. Thread t1 = new Thread(test);
  9. Thread t2 = new Thread(test);
  10. t1.setName("t1");
  11. t2.setName("t2");
  12. t1.start();
  13. t2.start();
  14. }
  15. //  public void run() {
  16. //      timer.add(Thread.currentThread().getName());
  17. //  }
  18. //   public void run() {
  19. //       timer.add(Thread.currentThread().getName());
  20. //            try {
  21. //                Thread.sleep(1000);//为了显示结果，让其睡眠一秒
  22. //            } catch (InterruptedException ex) {
  23. //                Logger.getLogger(TestSync.class.getName()).log(Level.SEVERE, null, ex);
  24. //            }
  25. //          System.out.println(Thread.currentThread().getName() + "----");
  26. //        }
  27. public void run() {
  28. synchronized(timer){
  29. timer.add(Thread.currentThread().getName());
  30. try {
  31. Thread.sleep(3000);
  32. } catch (InterruptedException ex) {
  33. Logger.getLogger(TestSync.class.getName()).log(Level.SEVERE, null, ex);
  34. }
  35. System.out.println(Thread.currentThread().getName() + "----");
  36. }
  37. }
  38. }
  39. class Timer {
  40. private static int num = 0;
  41. //  public void add(String name) {
  42. //
  43. //      num++;
  44. //      try {
  45. //          Thread.sleep(1000);
  46. //      } catch (InterruptedException e) {
  47. //      }
  48. //      System.out.println(name + ", 你是第" + num + "个使用timer的线程");
  49. //
  50. //  }
  51. public void add(String name) {
  52. synchronized (this) {// 同步
  53. num++;
  54. try {
  55. Thread.sleep(1000);
  56. } catch (InterruptedException e) {
  57. }
  58. System.out.println(name + ", 你是第" + num + "个使用timer的线程");
  59. }
  60. }
  61. }
上一篇：Android中服务的生命周期回调方法


下一篇：帝国CMS文章随机调用等一些常用标签