為什么這種形式的塊同步比其他塊快？

Question

因此，我剛剛完成了有關同步的任務，並且對獲得的結果感到好奇，因為我不太了解為什么一種形式比另一種形式更快。

有一個帳戶類，定義如下：

public class Account {

    /*
     * ------------
     * Data members
     * ------------
     */

    /**
     * Attribute presents an account number
     */

    private int acc;
    /**
     * Attribute that presents an customer name
     */
    private String name;
    /**
     * Attribute that presents an account balance
     */
    private double balance;

    /*
     * ------------
     * Constructors
     * ------------
     */

    /**
     * Assigns account number, name and balance.
     *
     * @param acc A unique integer that represents account number
     * @param name A string indicating human-readable customer's name
     * @param balance A double indicating account balance
     */

    public Account(int acc, String name, double balance) {
        super();
        this.acc = acc;
        this.name = name;
        this.balance = balance;
    }


    @Override
    /**
     * equals method works as == operator 
     * it checks if two accounts are identical
     */
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        Account other = (Account) obj;
        if (acc != other.acc)
            return false;
        if (Double.doubleToLongBits(balance) != Double
                .doubleToLongBits(other.balance))
            return false;
        if (name == null) {
            if (other.name != null)
                return false;
        } else if (!name.equals(other.name))
            return false;
        if (acc!=other.acc)return false;
        return true;
    }

    /**
     * Accessor for account no
     * @return account no
     */
    public int getAcc() {
        return acc;
    }

    /**
     * Mutator for account no 
     * @param acc A unique int for acoount number
     */
    public void setAcc(int acc) {
        this.acc = acc;
    }

    /**
     * Accessor for a customer's name
     * @return a customer's name
     */
    public String getName() {
        return name;
    }

    /**
     * Mutator for a customer name
     * @param name A string that represents a customer name
     */
    public void setName(String name) {
        this.name = name;
    }

    /**
     * Accessor for account balance
     * @return an account balance
     */
    public double getBalance() {
        return balance;
    }

    /**
     * Mutator for account balance
     * @param balance A double that represents an account balance
     */
    public void setBalance(double balance) {
        this.balance = balance;
    }

    /**
     * A method to print this account 
     */
    public String toString(){
        return "Account: "+acc+" \tName: "+name+" \tBalance:\t"+balance;
    }

    /**
     * A method that allows a customer to deposit money into this account
     * @param amount A double that represents a deposit amount
     */
    public void debosit(double amount){

        // Waste some time doing fake computations
        // do not remove or modify any of the following 3 statements
        double k = 999999999;
        for(int i=0;i<100;i++)
            k = k / 2;
            balance = balance + amount;
        // Waste some time doing fake computations
        // do not remove or modify any of the following 3 statements
        k = 999999999;
        for(int i=0;i<100;i++)
            k = k / 2;

    }

    /**
     * A method that allows a customer to withdraw money from this account
     * @param amount A double that represents a withdrawal amount
     */
    public void withdraw(double amount){

        // Waste some time doing fake computations
        // do not remove or modify any of the following 3 statements

        double k = 999999999;
        for(int i=0;i<100;i++)
            k = k / 2;
            balance = balance - amount;
        // Waste some time doing fake computations
        // do not remove or modify any of the following 3 statements
        k = 999999999;
        for(int i=0;i<100;i++)
            k = k / 2;
    }


}

public void debosit(double amount){

        // Waste some time doing fake computations
        // do not remove or modify any of the following 3 statements
        double k = 999999999;
        for(int i=0;i<100;i++)
            k = k / 2;
            balance = balance + amount;
        // Waste some time doing fake computations
        // do not remove or modify any of the following 3 statements
        k = 999999999;
        for(int i=0;i<100;i++)
            k = k / 2;

    }

    /**
     * A method that allows a customer to withdraw money from this account
     * @param amount A double that represents a withdrawal amount
     */
    public void withdraw(double amount){

        // Waste some time doing fake computations
        // do not remove or modify any of the following 3 statements

        double k = 999999999;
        for(int i=0;i<100;i++)
            k = k / 2;
            balance = balance - amount;
        // Waste some time doing fake computations
        // do not remove or modify any of the following 3 statements
        k = 999999999;
        for(int i=0;i<100;i++)
            k = k / 2;
    }

存款人類如下所示：

public class Depositor extends Thread {
    private Account account ;
    public Depositor(Account account){
        this.account = account;
    }


    public void run(){
        synchronized(account){
        for (int i=0;i<10000000;i++)
        {
            account.debosit(10);
            }
        /*          
        try {
                sleep(10);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }*/
        }

    }

}

而且提款器類類似於存款，只是運行提款方法而不是存款一種。

具有main方法的類如下：

public class AccountManager {
    public static void main(String[] args) {
        // TODO Auto-generated method stub

        Account [] account = new Account[10];
        Depositor [] deposit = new Depositor[10];
        Withdrawer [] withdraw = new Withdrawer[10];

        // The birth of  10 accounts
        account[0] = new Account(1234,"Mike",1000);
        account[1] = new Account(2345,"Adam",2000);
        account[2] = new Account(3456,"Linda",3000);
        account[3] = new Account(4567,"John",4000);
        account[4] = new Account(5678,"Rami",5000);
        account[5] = new Account(6789,"Lee",6000);
        account[6] = new Account(7890,"Tom",7000);
        account[7] = new Account(8901,"Lisa",8000);
        account[8] = new Account(9012,"Sam",9000);
        account[9] = new Account(4321,"Ted",10000);

        // The birth of 10 depositors 
        deposit[0] = new Depositor(account[0]);
        deposit[1] = new Depositor(account[1]);
        deposit[2] = new Depositor(account[2]);
        deposit[3] = new Depositor(account[3]);
        deposit[4] = new Depositor(account[4]);
        deposit[5] = new Depositor(account[5]);
        deposit[6] = new Depositor(account[6]);
        deposit[7] = new Depositor(account[7]);
        deposit[8] = new Depositor(account[8]);
        deposit[9] = new Depositor(account[9]);

        // The birth of  10 withdraws 
        withdraw[0] = new Withdrawer(account[0]);
        withdraw[1] = new Withdrawer(account[1]);
        withdraw[2] = new Withdrawer(account[2]);
        withdraw[3] = new Withdrawer(account[3]);
        withdraw[4] = new Withdrawer(account[4]);
        withdraw[5] = new Withdrawer(account[5]);
        withdraw[6] = new Withdrawer(account[6]);
        withdraw[7] = new Withdrawer(account[7]);
        withdraw[8] = new Withdrawer(account[8]);
        withdraw[9] = new Withdrawer(account[9]);

        System.out.println("Print initial account balances");
        // Print initial account balances
        for(int i=0;i<10;i++)
            System.out.println(account[i]);

        // Get start time in milliseconds 
        long start = System.currentTimeMillis(); 

        System.out.println("Depositor and Withdrawal threads have been created");
        /*
         * Interleave all threads
         */
        for(int i=0; i<10; i++){
            deposit[i].start();
            withdraw[i].start();
        }


        for(int i=0; i<10; i++){
            try {
                deposit[i].join();
                withdraw[i].join();
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
        // Get elapsed time in milliseconds 
        long elapsedTimeMillis = System.currentTimeMillis()-start; 

        System.out.println("Print final account balances after all the child thread terminated...");
        // Print final account balances after all the child thread terminated...    
        for(int i=0;i<10;i++)
            System.out.println(account[i]);
        // Get elapsed time in seconds 
        float elapsedTimeSec = elapsedTimeMillis/1000F;

        System.out.println("Elapsed time in milliseconds "+elapsedTimeMillis);
        System.out.println("Elapsed time in seconds is "+elapsedTimeSec);

        //  Get elapsed time in minutes 
        float elapsedTimeMin = elapsedTimeMillis/(60*1000F); 
        // Get elapsed time in hours 
        float elapsedTimeHour = elapsedTimeMillis/(60*60*1000F); 
        // Get elapsed time in days 
        float elapsedTimeDay = elapsedTimeMillis/(24*60*60*1000F); 

    }

}

抱歉，有很多代碼，但是最后我的問題是：

如果使用塊同步，則可以將其直接放在帳戶類中，如下所示：

public void withdraw(double amount){

        // Waste some time doing fake computations
        // do not remove or modify any of the following 3 statements

        double k = 999999999;
        for(int i=0;i<100;i++)
            k = k / 2;
            synchronized(this)
                balance = balance - amount;
        // Waste some time doing fake computations
        // do not remove or modify any of the following 3 statements
        k = 999999999;
        for(int i=0;i<100;i++)
            k = k / 2;
    }

兩種解決方案都完成后，總共需要1秒鍾才能運行。 但是，如果將同步轉移到提款機和存款人類，則看起來像這樣：

public void run(){

        // Withdraw 10 CAD into instance variable account
        for (int i=0;i<10000000;i++)
        {
            synchronized(account)
                account.withdraw(10);

        }
    }

這大約需要運行時間的1/10。

為什么是這樣？ 他們不應該花相同的時間嗎？

Answer 1

鎖定有開銷。 如果鎖定次數增加了100倍，則鎖定開銷應增加100倍。

之所以看不到100倍的差異，而只有10倍的原因，是因為代碼在做其他事情，但是如果您只有鎖定，您會注意到更大的差異。 除非JIT編譯器會注意到循環中的同步塊並將其吊起，否則似乎在測試中沒有這樣做。

Answer 2

如果同步塊位於withdraw()方法上，則一次只能有一個線程執行該方法，這意味着當一個線程正在執行“偽計算”時，其他線程必須等待。 看起來像這樣：

獲取鎖->偽造計算器->修改余額->偽造計算器->釋放鎖

但是，如果僅同步更改方法中的一行，而1個線程擁有鎖，則其他線程可以執行“偽計算”，這樣可以節省一些時間。 看起來像這樣

假計算器->獲取鎖->修改余額->釋放鎖->假計算器

注意，在第二種同步方式中，線程可以在另一個線程修改余額並釋放鎖之后立即獲取鎖，因此它不必等待偽計算。