`
xiangxingchina
  • 浏览: 524032 次
  • 性别: Icon_minigender_1
  • 来自: 北京
社区版块
存档分类
最新评论

Java中锁的机制

Javathread 
阅读更多

一、采用synchronized关键字。
实现用时就是放该关键字到方法前面，表示该方法是同步的，同一时间只能有一个线程使用它。但是有区别：

1、静态方法前加synchronized关键字表示所有此类的不同实例调用这个方法的时候都是串行的。
2、非静态方法前标识某一个实例被不同的线程调用时是串行的，但是不同实例之间是并行的。

例如：

  1. /**
  2. * 测试synchronized的区别
  3. *
  4. * @author <a href="mailto:HL_Qu@hotmail.com">Along</a>
  5. *
  6. * @version $Revision$
  7. *
  8. * @since 2009-3-24
  9. */
  10. public class TestSynchronized implements Runnable {

  12.     /**
  13.      * 所有类实例等待一个锁
  14.      */
  15.     private synchronized static void test() throws InterruptedException {
  16.         System.out.println("Obj= in.");
  17.         Thread.sleep(4000);
  18.         System.out.println("Obj= out.");
  19.     }
  20.    
  21.     /**
  22.      * 同一个实例的不同线程等待一个锁
  23.      */
  24.     private synchronized void test2() throws InterruptedException {
  25.         System.out.println("Obj=" + this + "in.");
  26.         Thread.sleep(4000);
  27.         System.out.println("Obj=" + this + "out.");
  28.     }

  30.     @Override
  31.     public void run() {
  32.         try {
  33.             test();
  34.             this.test2();
  35.         } catch (InterruptedException e) {
  36.             e.printStackTrace();
  37.         }
  38.     }

  40.     public static void main(String[] args) {
  41.         TestSynchronized a = new TestSynchronized();
  42.         TestSynchronized b = new TestSynchronized();

  44.         new Thread(a).start();
  45.         new Thread(b).start();
  46.     }
  47. }

输出：

  1. Obj= in.
  2. Obj= out.
  3. Obj= in.
  4. Obj=TestSynchronized@61de33in.
  5. Obj= out.
  6. Obj=TestSynchronized@ca0b6in.
  7. Obj=TestSynchronized@61de33out.
  8. Obj=TestSynchronized@ca0b6out.

synchronized还有一种使用方式就是同步代码块。例如：

  1. /**
  2. * 模拟静态方法锁机制
  3. *
  4. * @author <a href="mailto:HL_Qu@hotmail.com">Along</a>
  5. *
  6. * @version $Revision$
  7. *
  8. * @since 2009-3-24
  9. */
  10. public class TestLock2 implements Runnable {

  12.     private static String lock = new String("Locker");

  14.     /**
  15.      * 所有类实例等待一个锁
  16.      */
  17.     private void test() {
  18.         System.out.println("Obj=" + this + "in.");
  19.         synchronized (lock) {
  20.             System.out.println("Obj=" + this + "Locked.");
  21.             try {
  22.                 Thread.sleep(4000);
  23.             } catch (InterruptedException e) {
  24.                 e.printStackTrace();
  25.             }
  26.             System.out.println("Obj=" + this + "Unlocked.");
  27.         }

  29.         System.out.println("Obj=" + this + "out.");
  30.     }
  31.    
  32.     /**
  33.      * 同一个实例的不同线程等待一个锁
  34.      */
  35.     private void test2() {
  36.         System.out.println("Obj=" + this + "in.");
  37.         synchronized (this) {
  38.             System.out.println("Obj=" + this + "Locked.");
  39.             try {
  40.                 Thread.sleep(4000);
  41.             } catch (InterruptedException e) {
  42.                 e.printStackTrace();
  43.             }
  44.             System.out.println("Obj=" + this + "Unlocked.");
  45.         }

  47.         System.out.println("Obj=" + this + "out.");
  48.     }
  49.    
  50.     @Override
  51.     public void run() {
  52.         this.test2();
  53.         this.test();
  54.     }
  55.    
  56.     public static void main(String[] args) {
  57.         TestLock2 a = new TestLock2();
  58.         TestLock2 b = new TestLock2();

  60.         new Thread(a).start();
  61.         new Thread(b).start();
  62.     }

  64. }

输出：

  1. Obj=TestLock2@61de33in.
  2. Obj=TestLock2@61de33Locked.
  3. Obj=TestLock2@14318bbin.
  4. Obj=TestLock2@14318bbLocked.
  5. Obj=TestLock2@14318bbUnlocked.
  6. Obj=TestLock2@14318bbout.
  7. Obj=TestLock2@14318bbin.
  8. Obj=TestLock2@14318bbLocked.
  9. Obj=TestLock2@61de33Unlocked.
  10. Obj=TestLock2@61de33out.
  11. Obj=TestLock2@61de33in.
  12. Obj=TestLock2@14318bbUnlocked.
  13. Obj=TestLock2@14318bbout.
  14. Obj=TestLock2@61de33Locked.
  15. Obj=TestLock2@61de33Unlocked.
  16. Obj=TestLock2@61de33out.

二、采用Java提供的并发类实现。

例如使用ReentrantLock(一个可重入的互斥锁 Lock，它具有与使用 synchronized 方法和语句所访问的隐式监视器锁相同的一些基本行为和语义，但功能更强大。)

代码:

  1. import java.util.concurrent.locks.ReentrantLock;

  3. /**
  4. * 用Java提供的工具类模拟静态方法锁机制
  5. *
  6. *
  7. * @author <a href="mailto:HL_Qu@hotmail.com">Along</a>
  8. *
  9. * @version $Revision$
  10. *
  11. * @since 2009-3-24
  12. */
  13. public class TestLock implements Runnable {

  15.     private static ReentrantLock lock = new ReentrantLock();

  17.     @Override
  18.     public void run() {
  19.         System.out.println("Obj=" + this + "in.");
  20.         if (lock.isLocked()) {
  21.             System.out.println("Method has been Locked.");
  22.         }
  23.         
  24.         lock.lock();
  25.         System.out.println("Obj=" + this + "Locked.");
  26.         try {
  27.             Thread.sleep(4000);
  28.         } catch (InterruptedException e) {
  29.             e.printStackTrace();
  30.         }
  31.         System.out.println("Obj=" + this + "Unlocked.");
  32.         lock.unlock();
  33.         
  34.         System.out.println("Obj=" + this + "out.");
  35.     }
  36.    
  37.     public static void main(String[] args) {
  38.         TestLock a = new TestLock();
  39.         TestLock b = new TestLock();

  41.         new Thread(a).start();
  42.         new Thread(b).start();
  43.     }

  45. }

输出:

  1. Obj=TestLock@61de33in.
  2. Obj=TestLock@61de33Locked.
  3. Obj=TestLock@14318bbin.
  4. Method has been Locked.
  5. Obj=TestLock@61de33Unlocked.
  6. Obj=TestLock@14318bbLocked.
  7. Obj=TestLock@61de33out.
  8. Obj=TestLock@14318bbUnlocked.
  9. Obj=TestLock@14318bbout.
分享到：
| IBatis的缓存
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    java锁机制Synchronizedjava锁机制Synchronized

    Java 锁机制 Synchronized 是 Java 语言中的一种同步机制，用于解决多线程并发访问共享资源时可能出现的一些问题。 Java 锁机制 Synchronized 的概念 在 Java 中，每个对象都可以被看作是一个大房子，其中有多个...

    Java锁机制详解.pdf

    在Java中，内置锁是通过synchronized关键字实现的，而显示锁则是通过java.util.concurrent.locks包中的接口和类实现的。显示锁的一个重要接口是Lock，它提供了对锁操作的更细粒度控制，而ReentrantLock是Lock的一个...

    彻底理解Java中的各种锁.pdf

    本文将详细介绍Java中包括乐观锁、悲观锁、自旋锁、可重入锁、读写锁等多种锁机制的概念、特点、应用场景及其优化技术。 1. 乐观锁与悲观锁 乐观锁与悲观锁反映了对数据并发访问策略的不同预期。乐观锁假设数据通常...

    java锁机制详解.pdf

    在Java中，主要的锁机制包括`synchronized`关键字和`Lock`接口（如`ReentrantLock`）。下面将详细讲解这两种锁机制及其应用。 1. `synchronized`关键字 `synchronized`用于标记方法或代码块，确保同一时间只有一个...

    Java的锁机制的学习和使用

    Java中的锁机制主要用于解决多线程环境下的资源竞争问题。在并发编程中，为了保证数据一致性与正确性，通常需要采用各种锁来控制对共享资源的访问。Java语言提供了多种锁机制，包括`synchronized`关键字、`...

    java锁详解.pdf

    5. 重量级锁：重量级锁是 synchronized 锁的一种实现方式，使用互斥量来实现锁机制。 二、ReentrantLock 锁 1. 锁的原理：ReentrantLock 锁是基于 AQS（AbstractQueuedSynchronizer）机制来实现的。 2. 锁的分类：...

    面向Java锁机制的字节码自动重构框架.zip

    Java锁机制是多线程编程中的关键组成部分，用于控制对共享资源的访问，确保并发环境下的数据一致性。本文将深入探讨Java锁机制，并基于提供的"面向Java锁机制的字节码自动重构框架"来讨论其背后的原理和应用。 在...

    java中的锁机制.md

    java中的锁机制(任务)

    java 读写锁代码

    Java 读写锁是Java并发编程中的一种重要机制，它为多线程环境下的数据访问提供了更为精细的控制。在Java的`java.util....通过阅读和分析`readwritelock`这个示例，开发者可以更好地掌握如何在Java中使用读写锁。

    面向Java锁机制的字节码自动重构框架.pdf

    静态分析是在不运行程序的情况下检查程序的行为，这里的目的是分析字节码中锁机制的使用，并给出转换重构的建议。重构后的字节码需要进行一致性验证，确保修改后的程序行为与原程序保持一致。 5. Lock2Lock重构工具...

    Java多线程锁机制相关原理实例解析

    Java中的锁机制主要分为三种：偏向锁、轻量级锁和重量级锁。 偏向锁是Java锁机制的一种，用于解决线程之间的竞争问题。偏向锁可以重入和经常使用某一个线程，且不会发生竞争。偏向锁的结构由 hashcode、age、biased...

    JAVA中锁概及运用.doc

    JAVA 中锁概及运用 JAVA 中锁是指在多线程环境下，用于控制对共享资源的访问的机制。锁是 Java 并发编程的核心概念之一，锁机制可以确保在多线程环境下，共享资源不会被多个线程同时访问，从而避免数据不一致和其他...

    JAVA中锁的解决方案.docx

    JAVA 中锁的解决方案 在 JAVA 中，锁是非常重要的概念，它可以帮助开发者解决多线程编程中出现的同步问题。在本文中，我们将深入介绍 JAVA 中锁的解决方案，包括乐观锁和悲观锁的定义、核心代码剖析以及使用场景。 ...

    Java 中的悲观锁和乐观锁的实现

    ### Java中的悲观锁与乐观锁实现详解 #### 一、悲观锁（Pessimistic Locking） 悲观锁是一种基于对数据安全性的保守态度而设计的锁机制。它假设数据在处理过程中很可能被外界修改，因此在整个数据处理过程中都会将...

    Java 等待唤醒机制

    在Java中，主要通过`Object`类提供的`wait()`、`notify()`和`notifyAll()`方法来实现这一机制。这些方法使得线程可以在特定条件下暂停执行，释放锁资源，等待其他线程的通知后再继续执行。 1. **`wait()`方法**：当...

    介绍了java中各种存在的锁机制、面试必备

    Java中的锁机制是多线程编程中的核心概念，对于理解和掌握Java并发性能至关重要。本文将深入探讨Java中各种锁的实现方式，以及它们在面试中常见的考点。 首先，最基本的锁是`synchronized`关键字，它提供了两种用法...

Magicbox
Global site tag (gtag.js) - Google Analytics