Java 多锁如何加速多线程代码？

与synchronized方法相比，

synchronized

语句如何加快代码速度

 public void stageOne() {

    synchronized (lock1) {
        list1.add(random.nextInt(100));
    }
}

public void stageTwo() {

     synchronized (lock2) {
        list2.add(random.nextInt(100));
    }
}
public void process() {
    for (int i = 0; i < 1000; i++) {
        stageOne();
        stageTwo();
    }
}


    Thread t1 = new Thread(new Runnable() {
        public void run() {
            process();
        }
    });

    Thread t2 = new Thread(new Runnable() {
        public void run() {
            process();
        }
    });

public void stageOne（）{
已同步（锁1）{
列表1.add（random.nextInt（100））；
}
}
公共空间stagewo（）{
已同步（锁2）{
列表2.add（random.nextInt（100））；
}
}
公共程序（）{
对于（int i=0；i<1000；i++）{
stageOne（）；
stagewo（）；
}
}
线程t1=新线程（新的可运行线程（）{
公开募捐{
过程（）；
}
});
线程t2=新线程（新可运行（）{
公开募捐{
过程（）；
}
});

如果我使用

public synchronized void stageOne（）

和

public synchronized void stagewo（）

，程序将花费更多的时间来完成。

如果

stageOne（）

和

stagewo（）

被声明为

synchronized

，它们将使用相同的锁。该锁将是包含这些方法的对象。这意味着这些方法不能同时执行

---

由于您有两个方法和两个线程，因此将有四个方法竞争同一个锁。如果两个方法都有自己的锁（如您提供的代码中所示），那么每个方法的一个实例可以同时执行。

假设每个阶段需要1秒来执行，并且启动两个线程

使用全局锁时，如果一个线程执行任何方法，另一个线程就不能执行任何方法。因此，总时间为2秒+2秒=4秒

T1
S1 ---- S2 --- end

T2
wait----------- S1 ---- S2 ---- end

有了2个锁，一旦第一个线程执行完stage1，第二个线程就可以执行stage1，而第一个线程执行stage2。因此，假设任务是完全可并行的，并且您有2个内核，那么第二个线程将等待1秒，然后执行其两个阶段，因此总时间为3秒

T1
S1 ---- S2 --- end

T2
wait--- S1 ----S2 ---- end

---

同步方法锁定整个方法。因此只有一个线程可以执行该方法，导致其他线程等待。

Syncronized语句锁定block not方法，因此它比Syncronized方法更快。

示例1（同步化方法）：假设有

一个公共厕所

。有

两个人

，他们都必须

小便

（尽可能快）但是只有一个人可以进入厕所，当它进入厕所时，

锁上了门。在这种情况下，
人2
必须
在门外等待
人1
打开厕所。同样的情况下，
同步方法
线程2在方法之外等待线程1打开锁。（8028毫秒）

示例2（同步块）：假设有
一个公共厕所
。有
两个人
，他们都必须
小便
（尽可能快）但在这种情况下，他们都可以进入厕所，但当他们进入厕所时，他们发现厕所里只有一个小便器。但在这种情况下，第二个人在厕所门内等待第一个人释放小便器。这与在门外或里面等没有多大区别，但是存在
差异（可能几秒钟）
。因此，在
同步块的情况下，线程2在函数内部但在块外部等待线程1释放锁。因此，同步块比同步方法花费的时间更短。（4252 ms）

真正的优势在于为不同的线程使用两个或更多的锁
，比如在第二个示例中，当两个人进入厕所时，他们发现
2个小便器
，他们都可以同时使用不同的小便器。相同的
线程1为函数n 1持有锁1，同时线程2为函数n持有锁2
功能2和更高版本在空闲时进行交换。这可能会节省更多时间。（2138毫秒）

您还可以检查上述每种情况下的时差，以便为不同的情况执行相同的代码。
a
synchronized method
几乎等于
synchronized（this）{..}
。因此，您正在锁定整个对象，因此方法不能同时运行，而两个列表上的专用锁允许每个线程在一个列表上工作。您可能已经在下面的答案中看到了这一点，但只是为了清楚地说明：这一区别与synchronized method和synchronized语句无关。这种差异完全是由于一个锁与两个锁造成的。@jameslarge几乎是因为在同一实例上同步元素与任何后续执行时存在微小差异
synchronized
方法将导致其他线程中的实例更新，一旦该方法返回-A
synchronized（this）
将在释放锁后立即触发更新-释放锁后可能会有语句，这对于
同步方法是不可能的。请注意
stagewo
当然不应该依赖于
stageOne
——也就是说，在线程中执行
stageOne
和
stagewo
之间，任何线程都可以执行这些方法中的任意一种。然而，这些方法的名称似乎表明方法调用之间存在依赖关系。@dognose，我的错误，我以为你在比较一个
synchronized
方法和一个方法，该方法的整个主体是一个
synchronized（this）{…}
语句。