java synchronized(一)

java synchronized主要用于控制线程同步，中间有很多小的细节，知识，这里我简单的整理一下，做个记录。主要用于方法和代码块的控制

先说说方法控制

模拟银行存款和取款，创建一个Account类，两个属性，一个name和accout。先存1w进去，在用一100个线程取钱1k和存1k。等待所有线程结束后，输出account。没有synchronized控制会造成account不等于1w。使用了synchronized结果正确，性能降低了很多。下面贴一下代码

参考：http://www.cnblogs.com/devinzhang/archive/2011/12/14/2287675.html

Account.java

package com.gxf.thread;

public class Account {
    public String name;
    public float amount;
    
    public Account(String name, float amount){
        this.name = name;
        this.amount = amount;
    }
    
    /**
     * 模拟存钱
     * @param amt
     */
    public synchronized void deposit(float amt){
        float tmp = amount;
        tmp += amt;
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            
            e.printStackTrace();
        }
        this.amount = tmp;
    }
    
    /**
     * 模拟取钱
     * @param amt
     */
    public synchronized void withdraw(float amt){
        float tmp = amount;
        tmp -= amt;
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {

            e.printStackTrace();
        }
        
        amount = tmp;
    }
}

测试类AccountTest.java

package com.gxf.thread;

public class AccountTest {

    public static void main(String[] args) {
        final int NUM_THREADS = 5;                    //线程总数
        Thread threads[] = new Thread[NUM_THREADS];
        final Account zhangsan = new Account("zhangsan", 10000);        //张三存1w到银行
        
        //1000个线程对张三账户进行存钱1k和取1k
        for(int i = 0; i < NUM_THREADS; i++){
            threads[i] = new Thread(new Runnable(){

                @Override
                public void run() {
                    zhangsan.deposit(1000);
                    zhangsan.withdraw(1000);
                }
                
            });
            threads[i].start();                        //线程开始
        }
        //等待所有线程结束
        for(int i = 0; i < NUM_THREADS; i++){
            try {
                threads[i].join();                    //等待该线程结束
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
        System.out.println("account = " + zhangsan.amount);
    }

}

还有就是修饰一个代码块

参考：http://javacrazyer.iteye.com/blog/759300/

类LockThread向屏幕输出1-9

两个线程同时访问lockThread向屏幕输出的方法，不同步将会输出如：1 1 2 2 3 3...用了同步输出如:1 2 3 ...1 2 3...

LockThread.java

package com.gxf.thread;

public class LockThread implements Runnable {

    @Override
    public void run() {
        synchronized(this){
            for(int i = 1; i < 10; i++){
                System.out.println(i);
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    
                    e.printStackTrace();
                }
            }
        }

    }

}

测试代码

LockThreadTest.java

package com.gxf.thread;

public class LockThreadTest {

    public static void main(String[] args) {
        LockThread lockThread = new LockThread();
        Thread thread1 = new Thread(lockThread);
        Thread thread2 = new Thread(lockThread);
        
        thread1.start();
        thread2.start();

    }

}

ps:我也没检查synchronized拼对没有~