package com.xhj.thread;

    /**

     * 线程同步的运用

     *

     * @author XIEHEJUN

     *

     */

    public class SynchronizedThread {

        class Bank {

            private int account = 100;

            public int getAccount() {

                return account;

            }

            /**

             * 用同步方法实现

             *

             * @param money

             */

            public synchronized void save(int money) {

                account += money;

            }

            /**

             * 用同步代码块实现

             *

             * @param money

             */

            public void save1(int money) {

                synchronized (this) {

                    account += money;

                }

            }

        }

class NewThread implements Runnable {

            private Bank bank;

            public NewThread(Bank bank) {

                this.bank = bank;

            }

            @Override

            public void run() {

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

                    // bank.save1(10);

                    bank.save(10);

                    System.out.println(i + "账户余额为：" + bank.getAccount());

                }

            }

        }

        /**

         * 建立线程，调用内部类

         */

        public void useThread() {

            Bank bank = new Bank();

            NewThread new_thread = new NewThread(bank);

            System.out.println("线程1");

            Thread thread1 = new Thread(new_thread);

            thread1.start();

            System.out.println("线程2");

            Thread thread2 = new Thread(new_thread);

            thread2.start();

        }

        public static void main(String[] args) {

            SynchronizedThread st = new SynchronizedThread();

            st.useThread();

        }

    }

ReentrantLock() : 创建一个ReentrantLock实例

lock() : 获得锁

unlock() : 释放锁 

       //只给出要修改的代码，其余代码与上同

        class Bank {

            private int account = 100;

            //需要声明这个锁

            private Lock lock = new ReentrantLock();

            public int getAccount() {

                return account;

            }

            //这里不再需要synchronized

            public void save(int money) {

                lock.lock();

                try{

                    account += money;

                }finally{

                    lock.unlock();

                }

            }

        ｝

注：BlockingQueue<E>定义了阻塞队列的常用方法，尤其是三种添加元素的方法，我们要多加注意，当队列满时：

　　add()方法会抛出异常

　　offer()方法返回false

　　put()方法会阻塞

7.使用原子变量实现线程同步

需要使用线程同步的根本原因在于对普通变量的操作不是原子的。

那么什么是原子操作呢？原子操作就是指将读取变量值、修改变量值、保存变量值看成一个整体来操作即-这几种行为要么同时完成，要么都不完成。在java的util.concurrent.atomic包中提供了创建了原子类型变量的工具类，使用该类可以简化线程同步。其中AtomicInteger 表可以用原子方式更新int的值，可用在应用程序中(如以原子方式增加的计数器)，但不能用于替换Integer；可扩展Number，允许那些处理机遇数字类的工具和实用工具进行统一访问。

AtomicInteger类常用方法：

AtomicInteger(int initialValue) : 创建具有给定初始值的新的

AtomicIntegeraddAddGet(int dalta) : 以原子方式将给定值与当前值相加

get() : 获取当前值

代码实例：

只改Bank类，其余代码与上面第一个例子同

class Bank {

    private AtomicInteger account = new AtomicInteger(100);

    public AtomicInteger getAccount() {

        return account;

    }

    public void save(int money) {

        account.addAndGet(money);

    }

}

补充--原子操作主要有：　　

对于引用变量和大多数原始变量(long和double除外)的读写操作；　　

对于所有使用volatile修饰的变量(包括long和double)的读写操作。

摘自：http://www.cnblogs.com/duanxz/p/3709608.html