我知道

When you synchronize a block of code, you specify which object’s lock

you want to use as the lock, so you could, for example, use some

third-party object as the lock for this piece of code. That gives you

the ability to have more than one lock for code synchronization within

a single object.

但是,我不明白需要将参数传递给块.因为我是否传递String的实例并不重要,无论传递给块的参数如何,作为同步块的同步块的一些随机类的实例都能正常工作.

所以我的问题是,如果无论如何同步块阻止两个线程同时进入临界区.那么为什么需要传递一个论点呢？ (我的意思是默认获取某些随机对象的锁定).

我希望我正确地提出了我的问题.

我尝试了以下示例,随机参数是同步块.

public class Launcher {

public static void main(String[] args) {

AccountOperations accOps=new AccountOperations();

Thread lucy=new Thread(accOps,"Lucy");

Thread sam=new Thread(accOps,"Sam");

lucy.start();

sam.start();

}

}

使用非静态同步块：

public class AccountOperations implements Runnable{

private Account account = new Account();

public void run(){

for(int i=0;i<5;i++){

makeWithdrawal(10);

}

}

public void makeWithdrawal(int amount){

String str="asd"

synchronized (str /* pass any non-null object the synchronized block works*/) {

if(account.getAmount()>10){

try{

Thread.sleep(5000);

}catch(InterruptedException e){

e.printStackTrace();

}

account.withdraw(amount);

System.out.println(Thread.currentThread().getName()+" has withdrawn 10, current balance "+ account.getAmount());

}else{

System.out.println("Insufficient funds "+account.getAmount());

}

}

}

}

使用静态同步块：

public class AccountOperations implements Runnable{

private static Account account = new Account();

public void run(){

for(int i=0;i<5;i++){

makeWithdrawal(10);

}

}

public static void makeWithdrawal(int amount){

synchronized (String.class /* pass any class literal synchronized block works*/) {

if(account.getAmount()>10){

try{

Thread.sleep(5000);

}catch(InterruptedException e){

e.printStackTrace();

}

account.withdraw(amount);

System.out.println(Thread.currentThread().getName()+" has withdrawn 10, current balance "+ account.getAmount());

}else{

System.out.println("Insufficient funds "+account.getAmount());

}

}

}

}