「java同步快」java中同步

博主：adminadmin 2023-03-18 12:48:11 570

今天给各位分享java同步快的知识，其中也会对java中同步进行解释，如果能碰巧解决你现在面临的问题，别忘了关注本站，现在开始吧！

本文目录一览：

初学Java多线程：使用Synchronized块同步方法

synchronized关键字有两种用法 第一种就是在《使用Synchronized关键字同步类方法》一文中所介绍的直接用在方法的定义中 另外一种就是synchronized块 我们不仅可以通过synchronized块来同步一个对象变量 也可以使用synchronized块来同步类中的静态方法和非静态方法

synchronized块的语法如下

public void method()

{

    … …

    synchronized(表达式)

    {

        … …

    }

}

一 非静态类方法的同步

从《使用Synchronized关键字同步类方法》一文中我们知道使用synchronized关键字来定义方法就会锁定类中所有使用synchronzied关键字定义的静态方法或非静态方法 但这并不好理解 而如果使用synchronized块来达到同样的效果 就不难理解为什么会产生这种效果了 如果想使用synchronized块来锁定类中所有的同步非静态方法 需要使用this做为synchronized块的参数传入synchronized块国 代码如下

通过synchronized块同步非静态方法

public class SyncBlock

{

      public void method ()

      {

          synchronized(this)  // 相当于对method 方法使用synchronized关键字

          {

              … …

          }

      }

      public void method ()

      {

          synchronized(this)  // 相当于对method 方法使用synchronized关键字

          {

              … …

          }

      }

      public synchronized void method ()

      {

          … …

      }

  }

在上面的代码中的method 和method 方法中使用了synchronized块 而第 行的method 方法仍然使用synchronized关键字来定义方法 在使用同一个SyncBlock类实例时 这三个方法只要有一个正在执行 其他两个方法就会因未获得同步锁而被阻塞 在使用synchronized块时要想达到和synchronized关键字同样的效果 必须将所有的代码都写在synchronized块中 否则 将无法使当前方法中的所有代码和其他的方法同步

除了使用this做为synchronized块的参数外 还可以使用SyncBlock this作为synchronized块的参数来达到同样的效果

在内类（InnerClass）的方法中使用synchronized块来时 this只表示内类 和外类(OuterClass)没有关系 但内类的非静态方法可以和外类的非静态方法同步 如在内类InnerClass中加一个method 方法 并使method 方法和SyncBlock的三个方法同步 代码如下

使内类的非静态方法和外类的非静态方法同步

public class SyncBlock

{

    … …

    class InnerClass

    {

        public void method ()

        {

            synchronized(SyncBlock this)

            {

                … …

            }

        }

    }

    … …

}

在上面SyncBlock类的新版本中 InnerClass类的method 方法和SyncBlock类的其他三个方法同步 因此 method method method 和method 四个方法在同一时间只能有一个方法执行

Synchronized块不管是正常执行完 还是因为程序出错而异常退出synchronized块 当前的synchronized块所持有的同步锁都会自动释放 因此 在使用synchronized块时不必担心同步锁的释放问题

二 静态类方法的同步

由于在调用静态方法时 对象实例不一定被创建 因此 就不能使用this来同步静态方法 而必须使用Class对象来同步静态方法 代码如下

通过synchronized块同步静态方法

public class StaticSyncBlock

  {

      public static void method ()

      {

          synchronized(StaticSyncBlock class)

          {

              … …

          }

      }

      public static synchronized void method ()

      {

          … …

      }

  }

在同步静态方法时可以使用类的静态字段class来得到Class对象 在上例中method 和method 方法同时只能有一个方法执行 除了使用class字段得到Class对象外 还可以使用实例的getClass方法来得到Class对象 上例中的代码可以修改如下

使用getClass方法得到Class对象

public class StaticSyncBlock

{

    public static StaticSyncBlock instance;

    public StaticSyncBlock()

    {

        instance = this;

    }

    public static void method ()

    {

       synchronized(instance getClass())

       {

       }

    }

}

在上面代码中通过一个public的静态instance得到一个StaticSyncBlock类的实例 并通过这个实例的getClass方法得到了Class对象（一个类的所有实例通过getClass方法得到的都是同一个Class对象 因此 调用任何一个实例的getClass方法都可以） 我们还可以通过Class对象使不同类的静态方法同步 如Test类的静态方法method和StaticSyncBlock类的两个静态方法同步 代码如下

Test类的method方法和StaticSyncBlock类的method method 方法同步

public class Test

{

    public static void method()

    {

        synchronized(StaticSyncBlock class)

        {

        }

    }

}

lishixinzhi/Article/program/Java/gj/201311/27374

java 方法同步

1.同步方法 即有synchronized关键字修饰的方法。 由于java的每个对象都有一个内置锁，当用此关键字修饰方法时， 内置锁会保护整个方法。在调用该方法前，需要获得内置锁，否则就处于阻塞状态。 代码如： public synchronized void save(){} 注： synchronized关键字也可以修饰静态方法，此时如果调用该静态方法，将会锁住整个类 2.同步代码块 即有synchronized关键字修饰的语句块。 被该关键字修饰的语句块会自动被加上内置锁，从而实现同步 代码如： synchronized(object){ } 注：同步是一种高开销的操作，因此应该尽量减少同步的内容。 通常没有必要同步整个方法，使用synchronized代码块同步关键代码即可。 代码实例： 复制代码package com.xhj.thread; /** * 线程同步的运用 * * @author XIEHEJUN * */ public class SynchronizedThread { class Bank { private int account = 100; public int getAccount() { return account; } /** * 用同步方法实现 * * @param money */ public synchronized void save(int money) { account += money; } /** * 用同步代码块实现 * * @param money */ public void save1(int money) { synchronized (this) { account += money; } } } class NewThread implements Runnable { private Bank bank; public NewThread(Bank bank) { this.bank = bank; } @Override public void run() { for (int i = 0; i 10; i++) { // bank.save1(10); bank.save(10); System.out.println(i + "账户余额为：" + bank.getAccount()); } } } /** * 建立线程，调用内部类 */ public void useThread() { Bank bank = new Bank(); NewThread new_thread = new NewThread(bank); System.out.println("线程1"); Thread thread1 = new Thread(new_thread); thread1.start(); System.out.println("线程2"); Thread thread2 = new Thread(new_thread); thread2.start(); } public static void main(String[] args) { SynchronizedThread st = new SynchronizedThread(); st.useThread(); } }复制代码 3.使用特殊域变量(volatile)实现线程同步 a.volatile关键字为域变量的访问提供了一种免锁机制， b.使用volatile修饰域相当于告诉虚拟机该域可能会被其他线程更新， c.因此每次使用该域就要重新计算，而不是使用寄存器中的值 d.volatile不会提供任何原子操作，它也不能用来修饰final类型的变量 例如： 在上面的例子当中，只需在account前面加上volatile修饰，即可实现线程同步。 代码实例： 复制代码 //只给出要修改的代码，其余代码与上同 class Bank { //需要同步的变量加上volatile private volatile int account = 100; public int getAccount() { return account; } //这里不再需要synchronized public void save(int money) { account += money; } ｝复制代码 注：多线程中的非同步问题主要出现在对域的读写上，如果让域自身避免这个问题，则就不需要修改操作该域的方法。 用final域，有锁保护的域和volatile域可以避免非同步的问题。 4.使用重入锁实现线程同步 在JavaSE5.0中新增了一个java.util.concurrent包来支持同步。 ReentrantLock类是可重入、互斥、实现了Lock接口的锁， 它与使用synchronized方法和快具有相同的基本行为和语义，并且扩展了其能力 ReenreantLock类的常用方法有： ReentrantLock() : 创建一个ReentrantLock实例 lock() : 获得锁 unlock() : 释放锁 注：ReentrantLock()还有一个可以创建公平锁的构造方法，但由于能大幅度降低程序运行效率，不推荐使用 例如： 在上面例子的基础上，改写后的代码为: 代码实例： 复制代码//只给出要修改的代码，其余代码与上同 class Bank { private int account = 100; //需要声明这个锁 private Lock lock = new ReentrantLock(); public int getAccount() { return account; } //这里不再需要synchronized public void save(int money) { lock.lock(); try{ account += money; }finally{ lock.unlock(); } } ｝复制代码 注：关于Lock对象和synchronized关键字的选择： a.最好两个都不用，使用一种java.util.concurrent包提供的机制， 能够帮助用户处理所有与锁相关的代码。 b.如果synchronized关键字能满足用户的需求，就用synchronized，因为它能简化代码 c.如果需要更高级的功能，就用ReentrantLock类，此时要注意及时释放锁，否则会出现死锁，通常在finally代码释放锁 5.使用局部变量实现线程同步 如果使用ThreadLocal管理变量，则每一个使用该变量的线程都获得该变量的副本， 副本之间相互独立，这样每一个线程都可以随意修改自己的变量副本，而不会对其他线程产生影响。 ThreadLocal 类的常用方法 ThreadLocal() : 创建一个线程本地变量 get() : 返回此线程局部变量的当前线程副本中的值 initialValue() : 返回此线程局部变量的当前线程的"初始值" set(T value) : 将此线程局部变量的当前线程副本中的值设置为value 例如： 在上面例子基础上，修改后的代码为： 代码实例： 复制代码//只改Bank类，其余代码与上同 public class Bank{ //使用ThreadLocal类管理共享变量account private static ThreadLocalInteger account = new ThreadLocalInteger(){ @Override protected Integer initialValue(){ return 100; } }; public void save(int money){ account.set(account.get()+money); } public int getAccount(){ return account.get(); } }复制代码 注：ThreadLocal与同步机制 a.ThreadLocal与同步机制都是为了解决多线程中相同变量的访问冲突问题。 b.前者采用以"空间换时间"的方法，后者采用以"时间换空间"的方式。

Java中的同步——示例程序

前面说到了Java中的同步问题 下面通过一个小小的实例程序来演示Java中的同步方法 其中对前文提到的Counter类做了稍微的修改

public class Counter {

private int c = ;

public void increment() {

System out println( before increment c = + c);

c++;

try {

Thread sleep( );

} catch (InterruptedException e) {

e printStackTrace();

}

System out println( after increment c = + c);

}

public  void decrement() {

System out println( before decrement c = + c);

c ;

try {

Thread sleep( );

} catch (InterruptedException e) {

e printStackTrace();

}

System out println( after decrement c = + c);

}

public int value() {

return c;

}

}

在上面的Counter类的实现中 分别对increment和decrement方法中增加了sleep( )的调用 这样做的目的是为了放大两个线程对同一对象的方法调用时的交错效果

下面是两个线程 在ThreadA中调用了 次increment()方法 在ThreadB中调用了 次decrement()方法

Thread

public class ThreadA implements Runnable {

private Counter c;

public ThreadA(Counter c) {

this c = c;

}

@Override

public void run() {

for (int i = ; i ; i++) {

this c increment();

}

}

}

ThreadB

public class ThreadB implements Runnable {

private Counter c;

public ThreadB(Counter c) {

this c = c;

}

@Override

public void run() {

for (int i = ; i ; i++) {

this c decrement();

}

}

}

主程序如下 其中生成了两个线程threadA和ThreadB 他们共享Counter c

public class Main {

public static void main(String[] args) {

Counter c = new Counter();

ThreadA a = new ThreadA(c);

ThreadB b = new ThreadB(c);

Thread threadA = new Thread(a);

Thread threadB = new Thread(b);

threadA start();

threadB start();

}

}

执行上面的代码 可能的结果如下

before increment c =

before decrement c =

after increment c =

before increment c =

after decrement c =

before decrement c =

after increment c =

before increment c =

after decrement c =

before decrement c =

after increment c =

before increment c =

after decrement c =

before decrement c =

after increment c =

before increment c =

after decrement c =

before decrement c =

after increment c =

before increment c =

after decrement c =

before decrement c =

after increment c =

before increment c =

after increment c =

before increment c =

after decrement c =

before decrement c =

after decrement c =

before decrement c =

after increment c =

before increment c =

after increment c =

before increment c =

after decrement c =

before decrement c =

after increment c =

after decrement c =

before decrement c =

after decrement c =

从上面的输出结果中我们不难看出出现了严重的交错现象！ 在increment或者是decrement方法中输出before和after本应该是成对连续出现的 但输出结果却不是如此

将上面代码的increment()和decrement()方法用synchronized 修饰后 重新运行该程序 输出结果如下

before increment c =

after increment c =

before increment c =

after increment c =

before decrement c =

after decrement c =

before increment c =

after increment c =

before decrement c =

after decrement c =

before decrement c =

after decrement c =

before decrement c =

after decrement c =

before decrement c =

after decrement c =

before increment c =

after increment c =

before decrement c =

after decrement c =

before decrement c =

after decrement c =

before decrement c =

after decrement c =

before decrement c =

after decrement c =

before increment c =

after increment c =

before decrement c =

after decrement c =

before increment c =

after increment c =

before increment c =

after increment c =

before increment c =

after increment c =

before increment c =

after increment c =

before increment c =

after increment c =

这样输出结果和没有增加synchronized修饰符时的大不相同 单独一次的increment和decrement方法并没有出现交错的现象 只是连续 次的increment()和decrement ()有交错（这个不是synchronized能解决的问题）

至少 我们从上面的实例程序中可以看到synchronized方法的作用了

lishixinzhi/Article/program/Java/hx/201311/26369

java同步锁慢怎么解决

百度知道

java同步锁慢怎么解决

173******87

超过41用户采纳过TA的回答

关注

成为第1位粉丝

性能优化的需求实现中，如果使用了多线程并行来提高程序运行效率，那么一个很难绕开的部分就是同步加锁。同步锁会将多线程并行执行强制合流为串行执行，通常会成为整个程序的性能瓶颈所在，所以锁性能的优化必不可少。一般来说，优化锁性能的关键如下：

降低锁竞争概率

提高锁竞争效率

1. 降低锁竞争概率

1.1 减小锁粒度

要降低锁竞争发生的概率，一个非常直观的思路是减小锁粒度，核心思想是将大的全局锁分割为一个个范围精确的小锁，使线程的竞争对象从全局锁变更为小锁，从而减少锁竞争发生

Java 线程同步几种方式

（1）同步方法：

即有synchronized关键字修饰的方法。 由于java的每个对象都有一个内置锁，当用此关键字修饰方法时，内置锁会保护整个方法。在调用该方法前，需要获得内置锁，否则就处于阻塞状态。

（2）同步代码块

即有synchronized关键字修饰的语句块。被该关键字修饰的语句块会自动被加上内置锁，从而实现同步

（3）使用特殊域变量(Volatile)实现线程同步

a.volatile关键字为域变量的访问提供了一种免锁机制

b.使用volatile修饰域相当于告诉虚拟机该域可能会被其他线程更新

c.因此每次使用该域就要重新计算，而不是使用寄存器中的值

d.volatile不会提供任何原子操作，它也不能用来修饰final类型的变量

（4）使用重入锁实现线程同步

在JavaSE5.0中新增了一个java.util.concurrent包来支持同步。ReentrantLock类是可重入、互斥、实现了Lock接口的锁， 它与使用synchronized方法和快具有相同的基本行为和语义，并且扩展了其能力。

（5）使用局部变量实现线程同步

java中实现同步的方法有哪两种?

Java的同步可以用synchronized关键字来实现。\x0d\x0a \x0d\x0asychronized可以同步代码，需要绑定一个对象，如synchronized(obj){}\x0d\x0a也可以同步一个方法，是对方法进行线程同步。如public void synchronized methodA(){}

关于java同步快和java中同步的介绍到此就结束了，不知道你从中找到你需要的信息了吗 ？如果你还想了解更多这方面的信息，记得收藏关注本站。

标签：