java之线程（二）

多线程

一、使用阻塞队列（BlockingQueue）控制线程通信

       BlockingQueue是一个接口，也是Queue的子接口。BlockingQueue具有一个特征：当生产者线程试图向BlockingQueue中放入元素时，如果该队列已满，则线程被阻塞；但消费者线程试图从BlockingQueue中取出元素时，如果队列已空，则该线程阻塞。程序的两个线程通过交替向BlockingQueue中放入元素、取出元素，即可很好地控制线程的通信。

BlockingQueue提供如下两个支持阻塞的方法：

  （1）put(E e)：尝试把Eu元素放如BlockingQueue中，如果该队列的元素已满，则阻塞该线程。

  （2）take（）：尝试从BlockingQueue的头部取出元素，如果该队列的元素已空，则阻塞该线程。

BlockingQueue接口包含如下5个实现类：

ArrayBlockingQueue ：基于数组实现的BlockingQueue队列。

LinkedBlockingQueue：基于链表实现的BlockingQueue队列。

PriorityBlockingQueue：它并不是保准的阻塞队列，该队列调用remove（）、poll（）、take（）等方法提取出元素时，并不是取出队列中存在时间最长的元素，而是队列中最小的元素。

                       它判断元素的大小即可根据元素（实现Comparable接口）的本身大小来自然排序，也可使用Comparator进行定制排序。

 

SynchronousQueue：同步队列。对该队列的存、取操作必须交替进行。

DelayQueue：它是一个特殊的BlockingQueue，底层基于PriorityBlockingQueue实现，不过，DelayQueue要求集合元素都实现Delay接口（该接口里只有一个long getDelay（）方法），

            DelayQueue根据集合元素的getDalay（）方法的返回值进行排序。

二、线程同步

 java允许多线程并发控制，当多个线程同时操作一个可共享的资源变量时（如数据的增删改查），将会导致数据不准确，相互之间产生冲突，因此加入同步锁以避免在该线程没有完成操作之前，被其他线程的调用，从而保证了该变量的唯一性和准确性。

1、同步方法     

      即有synchronized关键字修饰的方法。由于java的每个对象都有一个内置锁，当用此关键字修饰方法时，内置锁会保护整个方法。在调用该方法前，需要获得内置锁，否则就处于阻塞状态。

public synchronized void save(){}

 2、同步代码块     

     即有synchronized关键字修饰的语句块。被该关键字修饰的语句块会自动被加上内置锁，从而实现同步。

public class Bank { 

        private int count =0;//账户余额

        //存钱 

        public   void addMoney(int money){ 

            synchronized (this) { 

                count +=money; 

            } 

            System.out.println(System.currentTimeMillis()+"存进："+money); 

        } 

        //取钱 

        public   void subMoney(int money){ 

            synchronized (this) { 

                if(count-money < 0){ 

                    System.out.println("余额不足"); 

                    return; 

                } 

                count -=money; 

            } 

            System.out.println(+System.currentTimeMillis()+"取出："+money); 

        } 

        //查询 

        public void lookMoney(){ 

            System.out.println("账户余额："+count); 

        }

}

注：同步是一种高开销的操作，因此应该尽量减少同步的内容。通常没有必要同步整个方法，使用synchronized代码块同步关键代码即可。

3、使用特殊域变量(volatile)实现线程同步      

   • volatile关键字为域变量的访问提供了一种免锁机制；

   • 使用volatile修饰域相当于告诉虚拟机该域可能会被其他线程更新；

   • 因此每次使用该域就要重新计算，而不是使用寄存器中的值；

   • volatile不会提供任何原子操作，它也不能用来修饰final类型的变量

public class SynchronizedThread {

        class Bank {

            private volatile 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();

        }