`

synchronized的用法

 
阅读更多

1.synchronized的几种用法 synchronized关键字最主要有以下5种应用方式，下面分别介绍。 1. 修饰对象普通方法，作用于当前对象，进入同步方法前要获得当前对象的锁 2. 修饰对象静态方法，作用于当前类对象加锁，进入同步该方法前要获得当前类对象的锁 3. 修饰代码块，指定加锁对象，对给定对象加锁，进入同步代码库前要获得指定对象的锁。 4. 修饰 this，指定当前对象，对给当前对象加锁，进入同步代码前要获得当前对象的锁(该方式和方式1作用相同)。 5. 修饰 xxx.class，(该方式和方式2作用相同)。

 

 

2.锁竞争说明 同时调用两个都加有synchronized的方法时存在锁竞争关系（同时调用时会一个先输出，另一个晚两秒输出）以下代码同时调用会产生竞争关系（this的作用相同）

 

 

	public synchronized void getSex() throws InterruptedException {
		Thread.sleep(2000);
	    System.out.println("getSex synchronized : " + System.currentTimeMillis());
	}
	
	public synchronized void getHeight() throws InterruptedException {
	    Thread.sleep(2000);
	    System.out.println("getHeight synchronized : " + System.currentTimeMillis());
	}
	
	public void getWeight() throws InterruptedException {
	     synchronized (this){
	          Thread.sleep(2000);
	          System.out.println("getWeight synchronized : " + System.currentTimeMillis());
	     }
	}

 

  • 同时调用两个都加有synchronized的静态(static)方法时存在锁竞争关系（同时调用时会一个先输出，另一个晚两秒输出)
  • 	public static synchronized void getName() throws InterruptedException {
	     Thread.sleep(2000);
	     System.out.println("getName static synchronized : " + System.currentTimeMillis());
	}
	
	public static synchronized void getAge() throws InterruptedException {
	      Thread.sleep(2000);
	      System.out.println("getAge static synchronized : " + System.currentTimeMillis());
	}
  • 同时调用锁代码块的要看锁的目标是不是同一个，如果是同一个时就存在锁竞争关系，如果不是则没有关系 当传入的参数一样则有竞争关系
  • 这里要注意点的就是 当传入的是getWX(“55”)和getQQ(“55”),getWX(new String(“55”))和getQQ(new String(“55”))这两中的结果是不同的 注意前面的存在竞争关系，后面不存在，因为new 是从新创建了对象，内存地址不是同一个
  • 	public void getQQ(String qq) throws InterruptedException {
	      synchronized (qq){
	           Thread.sleep(2000);
	           System.out.println("getQQ QQ synchronized : " + System.currentTimeMillis());
	      }
	}
	
	public void getWX(String wx) throws InterruptedException {
	      synchronized (wx){
	           Thread.sleep(2000);
	           System.out.println("getWX WX synchronized : " + System.currentTimeMillis());
	      }
	}
     
  • 同时一个synchronized的静态(static)方法和一个普通synchronized方法时 和一个synchronized代码块时(代码块不是 this和xxx.class)，不存在竞争关系
  • 这里要注意点的就是 synchronized代码块必须不是this和xxx.class，要不然会有竞争关系 因为this和synchronized普通方法效果相同，xxx.class与synchronized静态方法效果相同
  • public synchronized void getSex() throws InterruptedException {
       Thread.sleep(2000);
       System.out.println("getSex synchronized : " + System.currentTimeMillis());
}

public static synchronized void getAge() throws InterruptedException {
      Thread.sleep(2000);
      System.out.println("getAge static synchronized : " + System.currentTimeMillis());
}

public void getWX(String wx) throws InterruptedException {
      synchronized (wx){
          Thread.sleep(2000);
          System.out.println("getWX WX synchronized : " + System.currentTimeMillis());
      }
}
     以下是全部代码 
  • /**
 * 文件介绍
 *
 * @author YangLD
 * @date 2018/8/3 21:17
 */
public class RunMain {


    static{
        System.out.println("static");
    }

    public static void main(String[] args) throws IllegalAccessException, InstantiationException {

        RunMain runMain = RunMain.class.newInstance();

        System.out.println(System.currentTimeMillis());
        CyclicBarrier cyclicBarrier = new CyclicBarrier(9);
        ThreadUtil.execute(new Runnable() {
            @Override
            public void run() {
                try {
                    cyclicBarrier.await();
                    RunMain.getName();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } catch (BrokenBarrierException e) {
                    e.printStackTrace();
                }
            }
        });
        ThreadUtil.execute(new Runnable() {
            @Override
            public void run() {
                try {
                    cyclicBarrier.await();
                    RunMain.getAge();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } catch (BrokenBarrierException e) {
                    e.printStackTrace();
                }
            }
        });
        ThreadUtil.execute(new Runnable() {
            @Override
            public void run() {
                try {
                    cyclicBarrier.await();
                    runMain.getEmail();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } catch (BrokenBarrierException e) {
                    e.printStackTrace();
                }
            }
        });
        ThreadUtil.execute(new Runnable() {
            @Override
            public void run() {
                try {
                    cyclicBarrier.await();
                    runMain.getSex();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } catch (BrokenBarrierException e) {
                    e.printStackTrace();
                }
            }
        });

        ThreadUtil.execute(new Runnable() {
            @Override
            public void run() {
                try {
                    cyclicBarrier.await();
                    runMain.getHeight();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } catch (BrokenBarrierException e) {
                    e.printStackTrace();
                }
            }
        });
        ThreadUtil.execute(new Runnable() {
            @Override
            public void run() {
                try {
                    cyclicBarrier.await();
                    runMain.getWeight();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } catch (BrokenBarrierException e) {
                    e.printStackTrace();
                }
            }
        });
        ThreadUtil.execute(new Runnable() {
            @Override
            public void run() {
                try {
                    cyclicBarrier.await();
                    runMain.getQQ("qq");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } catch (BrokenBarrierException e) {
                    e.printStackTrace();
                }
            }
        });
        ThreadUtil.execute(new Runnable() {
            @Override
            public void run() {
                try {
                    cyclicBarrier.await();
                    runMain.getWX("qq");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } catch (BrokenBarrierException e) {
                    e.printStackTrace();
                }
            }
        });
        ThreadUtil.execute(new Runnable() {
            @Override
            public void run() {
                try {
                    cyclicBarrier.await();
                    runMain.getAli();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } catch (BrokenBarrierException e) {
                    e.printStackTrace();
                }
            }
        });
    }


    public static synchronized void getName() throws InterruptedException {
        Thread.sleep(2000);
        System.out.println("getName static synchronized : " + System.currentTimeMillis());
    }

    public static synchronized void getAge() throws InterruptedException {
        Thread.sleep(2000);
        System.out.println("getAge static synchronized : " + System.currentTimeMillis());
    }

    public synchronized void getSex() throws InterruptedException {
        Thread.sleep(2000);
        System.out.println("getSex synchronized : " + System.currentTimeMillis());
    }

    public synchronized void getHeight() throws InterruptedException {
        Thread.sleep(2000);
        System.out.println("getHeight synchronized : " + System.currentTimeMillis());
    }

    public void getEmail() throws InterruptedException {
        Thread.sleep(2000);
        System.out.println("getEmail : " + System.currentTimeMillis());
    }

    public void getWeight() throws InterruptedException {
        synchronized (this){
            Thread.sleep(2000);
            System.out.println("getWeight synchronized : " + System.currentTimeMillis());
        }
    }

    public void getQQ(String qq) throws InterruptedException {
        synchronized (qq){
            Thread.sleep(2000);
            System.out.println("getQQ QQ synchronized : " + System.currentTimeMillis());
        }
    }

    public void getWX(String wx) throws InterruptedException {
        synchronized (wx){
            Thread.sleep(2000);
            System.out.println("getWX WX synchronized : " + System.currentTimeMillis());
        }
    }

    public void getAli() throws InterruptedException {
        synchronized (RunMain.class){
            Thread.sleep(2000);
            System.out.println("getAli synchronized : " + System.currentTimeMillis());
        }
    }
}
     　　1）CountDownLatch和CyclicBarrier都能够实现线程之间的等待，只不过它们侧重点不同：

    　　　　CountDownLatch一般用于某个线程A等待若干个其他线程执行完任务之后，它才执行；

    　　　　而CyclicBarrier一般用于一组线程互相等待至某个状态，然后这一组线程再同时执行；

    　　　　另外，CountDownLatch是不能够重用的，而CyclicBarrier是可以重用的。

    　　2）Semaphore其实和锁有点类似，它一般用于控制对某组资源的访问权限。

分享到：
| redis持久化
评论
发表评论

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

相关推荐

    java中synchronized用法

    "Java 中 synchronized 用法详解" Synchronized 是 Java 语言中用于解决多线程共享数据同步问题的关键字。它可以作为函数的修饰符，也可以作为函数内的语句，用于实现同步方法和同步语句块。在 Java 中，...

    java里面synchronized用法.doc

    Java 中的 synchronized 用法详解 Java 中的 synchronized 关键字是用于解决多线程并发问题的重要工具之一。它可以被用于方法、代码块和变量上，以实现对共享资源的互斥访问控制。本文将对 Java 中的 synchronized ...

    synchronized用法大全实例

    本实例大全将全面解析`synchronized`的使用方式，包括同步方法、同步语句块、类锁和对象锁。 ### 1. 同步方法 同步方法是通过在方法声明前加上`synchronized`关键字实现的。这样，同一时间只有一个线程可以执行该...

    java同步synchronized关键字用法示例

    - **代码块同步：** 也可以使用`synchronized`关键字来同步代码块，这样可以更细粒度地控制同步范围，提高程序性能。 ```java public void method() { synchronized (object) { // 代码块 } } ``` 这里的`object...

    synchronized关键字的用法详解

    `synchronized`关键字有两种主要的使用方式：一种是在方法声明中使用，另一种则是在代码块中使用。 ##### 1. synchronized方法 在方法声明中添加`synchronized`关键字，可以将整个方法体变成同步代码块。例如： `...

    解决Maven 项目报错 java.httpservlet和synchronized使用方法

    解决Maven项目报错java.httpservlet和synchronized使用方法 在Maven项目中，我们经常会遇到一些报错问题，例如java.httpservlet和synchronized使用方法等。这篇文章将为大家带来解决Maven项目报错java.httpservlet...

    Java synchronized使用案例

    一、`synchronized`的基本用法 1. **方法同步**：在方法声明前加上`synchronized`，整个方法都会被锁定，任何时刻只有一个线程能执行该方法。 ```java public synchronized void method() { // 方法体 } ``` 2. **...

    Synchronized关键字的用法

    - **实例方法**：可以直接将`synchronized`关键字放在实例方法前，此时该方法的锁为当前对象实例本身。 ```java public synchronized void method() { // 同步方法体 } ``` - 当一个线程调用此方法时，会锁定...

    Java 中 synchronized的用法详解(四种用法)

    下面将详细介绍 `synchronized` 的四种主要用法。 1. **修饰实例方法**： 当 `synchronized` 修饰一个实例方法时，它会锁定当前对象的监视器，即所谓的“成员锁”。这意味着同一时间只有一个线程可以执行该方法。...

    synchronized关键字的实质及用法

    本文将详细探讨`synchronized`的关键特性、用法以及它在实际开发中的应用。 1. **synchronized的两种使用方式** - **方法同步**：在方法声明前加上`synchronized`关键字，这将使得整个方法成为同步方法，每次只有...

    PHP pthreads v3下同步处理synchronized用法示例

    为了解决这个问题，可以使用`synchronized`包裹需要同步的代码块，确保同一时间只有一个线程能执行这段代码。 在pthreads v2中，线程同步通常使用Mutex（互斥锁）来实现，但在pthreads v3中，Mutex被移除，取而代之...

    Java中synchronized正确使用方法解析

    Java 中 synchronized 正确使用方法解析 Java 中 synchronized 关键字是解决线程安全问题的重要手段，它可以确保在多线程环境下，共享资源的访问安全性。本文将详细介绍 Java 中 synchronized 的正确使用方法，通过...

    Android synchronized 测试案例

    本测试案例深入探讨了`synchronized`的使用方法，包括同步单个对象、同步多个对象以及成功与失败的场景对比。 一、`synchronized`关键字的基本概念 `synchronized`关键字可以修饰方法或用作代码块，其主要作用是...

    synchronized并发讲解源码.zip

    `synchronized`还有一种高级用法——同步类方法（静态方法），这会锁定整个类，而非单个对象： ```java public class MyClass { public static synchronized void method() { // ... } } ``` 在这种情况下，所有...

    java锁机制Synchronizedjava锁机制Synchronized

    这些房间可以被分为两种：上锁房间（synchronized 方法）和不上锁房间（普通方法）。每个对象都有一个钥匙（key），该钥匙可以打开所有上锁的房间。 Synchronized 方法 当一个线程想要进入一个上锁房间时，它需要...

    [JAVA][synchronized的使用]

    本篇文章将深入探讨`synchronized`的使用，包括其基本原理、使用方式以及实际应用场景。 1. **synchronized的基本原理** `synchronized`关键字在Java中提供了互斥访问，也就是说，当一个线程进入一个对象的`...

    java多线程中的volatile和synchronized用法分析

    在Java多线程编程中，...总的来说，理解并熟练掌握volatile和synchronized的使用，对于编写高效、可靠的多线程Java程序至关重要。在实际开发中，应根据场景选择合适的方式，确保并发安全的同时，尽可能优化性能。

    volatile和synchronized的区别

    当一个线程访问某个对象的一个`synchronized`方法时，它就获得了该对象的锁，并且其他线程无法再访问该对象的其他`synchronized`方法。 - **互斥性**：通过`synchronized`关键字实现的锁具有互斥性，也就是说，一次...

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