java线程安全总结

受益匪浅，感谢

volatile的理解。
线程的有序性和内存可见性。
分析的很不错。

lz帖子里面讲的“有序性”不对啊，似乎想说happens-before，但是又不是说的happens-before，你这儿的“有序性”是“原子性”的意思吧？
volatile能够保证可见性，还能保证happens-before，这点似乎在帖子里面没有谈到。

是的，换我也投隐藏，现在没机会了，因为里面对volatile的解释是不对的。

请问LZ，是不是在方法内部申明的变量都是线程安全的？

谢谢ZL 看了这篇文章 受益了

楼主你好，按照你的代码，我也写了一个类，只不过有点小小的变动，为什么没有添加同步方法，执行结果却总是正确的，没有像你的结果那样是变化的。这个是怎么回事？

public class Account
{
    private int balance;

    public int getBalance()
    {
        return balance;
    }

    public Account( int balance )
    {
        this.balance = balance;
    }

    public void add( int amount )
    {
        System.out.println( "add:" + amount );
        balance += amount;
    }

    public void withdraw( int amount )
    {
        System.out.println( "withdraw:" + amount );
        balance -= amount;
    }

    public static void main( String[] args )
    {
        try
        {
            Account account = new Account( 100 );
            TransferUnit tuAdd = new TransferUnit( TransferUnit.ADD, 10 );
            TransferUnit tuWithDraw = new TransferUnit( TransferUnit.WITHDRAW,
                    10 );
            Transfer transferAdd = new Transfer( account, tuAdd );
            Transfer transferWD = new Transfer( account, tuWithDraw );
            Thread tAdd = new Thread( transferAdd, "add" );
            Thread tWD = new Thread( transferWD, "withdraw" );
            tAdd.start();
            tWD.start();
            tAdd.join();
            tWD.join();
            System.out.println( "result:" + account.getBalance() );
        } catch ( InterruptedException e )
        {
            e.printStackTrace();
        }

    }
}

class Transfer implements Runnable
{
    private Account account;
    private TransferUnit transferUnit;

    public Transfer( Account account,TransferUnit transferUnit )
    {
        this.account = account;
        this.transferUnit = transferUnit;
    }

    public Account getAccount()
    {
        return account;
    }

    public TransferUnit getTransferUnit()
    {
        return transferUnit;
    }

    public void run()
    {
        for ( int i = 0; i < 10000; i++ )
        {
            switch ( transferUnit.getTransferType() )
            {
                case TransferUnit.ADD:
                    account.add( transferUnit.getAmount() );
                    break;
                case TransferUnit.WITHDRAW:
                    account.withdraw( transferUnit.getAmount() );
                    break;
            }
            try
            {
                Thread.sleep( 2 );
            } catch ( InterruptedException e )
            {
                e.printStackTrace();
            }
        }
    }

}

class TransferUnit
{
    public static final int ADD = 1;
    public static final int WITHDRAW = 2;

    private int transferType;

    private int amount;

    public TransferUnit( int transferType,int amount )
    {
        this.transferType = transferType;
        this.amount = amount;
    }

    public int getAmount()
    {
        return amount;
    }

    public int getTransferType()
    {
        return transferType;
    }

}

楼主的文章写的浅显易懂啊，受益匪浅

同求~

这是我看过最好的多线程入门教程了。    消化下， 再找你的别的帖子看。


谢谢你啊 ， 无私啊！