java线程个人总结

最近，正学习java线程，总结如下：

java.util.concurrent.locks.Lock

void lock() 获得这个锁，如果这个锁当前被另一个线程所持有，则该线程发生阻塞。

void unlock() 释放锁定。

java.util.concurrent.locks.ReentrantLock

public ReentrantLock() 创建一个可被用来保护临界区的可重人锁。

用ReentrantLock保护代码块的基本结构如下：

myLock.lock(); // ReentrantLock对象 

try

{

     // 临界区

}

finally

{

     myLock.unlock(); // 确保锁能够释放

}

该结构保证在任何时刻只有一个线程能够进入临界区。一旦一个线程锁住了锁对象，其他任何线程都无法通过lock语句。当其他线程调用lock时，它们会被阻塞，直到第一线程释放锁对象。

使用Lock和Condition对象的关键点：

     1.锁用来保护代码片段，任何时刻只允许一个线程执行被保护的代码。

     2.锁可以管理试图进入被保护代码段的线程。

     3.锁可以拥有一个或多个相关的条件对象。

     4.每个条件对象管理那些已进入被保护代码段但还不能运行的线程。

Condition有两个方法可以唤醒等待线程：signalAll()方法和signal()方法。

signalAll()方法唤醒所有等待线程,该方法不会立即激活等待线程，它只是解除等待线程的阻塞状态，这样这些线程就可以在当前线程退出同步方法后，通过竞争获得对对象的访问。

而signal()方法则是随机解除等待集中某个线程的阻塞状态。该方法存在一定的危险，如果被随机选中的线程发现自己还是无法运行，它会再次被阻塞。如果没有任何其他线程再次调用singal()方法，那么系统就死锁了。

当一个线程调用await()方法时，它无法自己解除阻塞状态。它把自己的命运交给了其他线程。如果没有任何其他线程来解除等待线程的阻塞状态，它就永远也不会运行了，这会导致死锁。

例程1：SynchBankTest.java

public class TestSync implements Runnable {     Timer timer = new Timer();     public static void main(String[] args)     {          TestSync test = new TestSync();          Thread t1 = new Thread(test);          Thread t2 = new Thread(test);          t1.setName("t1");          t2.setName("t2");          t1.start();          t2.start();     }     public void run() {          timer.add(Thread.currentThread().getName());     }}class Timer {     private static int num = 0;     public /*synchronized*/ void add(String name) {          synchronized (this) {               num++;               try {                    Thread.sleep(1);               }               catch (InterruptedException e)               {               }               System.out.println(name + ", 你是第" + num + "个使用timer的线程");          }     }}

 

例程1：SynchBankTest.java

import java.util.concurrent.locks.*;/*** This program shows how multiple threads can safely access a data structure.*/public class SynchBankTest{     public static void main(String[] args)     {          Bank b = new Bank(NACCOUNTS, INITIAL_BALANCE);          int i;          for (i = 0; i < NACCOUNTS; i++)          {               TransferRunnable r = new TransferRunnable(b, i, INITIAL_BALANCE);               Thread t = new Thread(r);               t.start();          }     }     public static final int NACCOUNTS = 100;     public static final double INITIAL_BALANCE = 1000;}/*** A bank with a number of bank accounts.*/class Bank{     /**     * Constructs the bank.     * @param n the number of accounts     * @param initialBalance the initial balance     * for each account     */     public Bank(int n, double initialBalance)     {          accounts = new double[n];          for (int i = 0; i < accounts.length; i++)               accounts[i] = initialBalance;          bankLock = new ReentrantLock();          sufficientFunds = bankLock.newCondition();     }     /**     * Transfers money from one accounts to another.     * @param from the account to transfer from     * @param to the account to transfer to     * @param amount the amount to transfer     */     public void transfer(int from, int to, double amount)          throws InterruptedException     {          bankLock.lock();          try          {               while (accounts[from] < amount)                    sufficientFunds.await();               System.out.print(Thread.currentThread());               accounts[from] -= amount;               System.out.printf(" %10.2f from %d to %d", amount, from, to);               accounts[to] += amount;               System.out.printf(" Total Balance: %10.2f%n", getTotalBalance());               sufficientFunds.signalAll();          }          finally          {               bankLock.unlock();          }     }     /**     * Gets the sum of all account balances.     * @return the total balance     */     public double getTotalBalance()     {          bankLock.lock();          try          {               double sum = 0;               for (double a : accounts)                    sum += a;               return sum;          }          finally          {               bankLock.unlock();          }     }     /**     * Gets the number of accounts in the bank.     * @return the number of accounts     */     public int size()     {          return accounts.length;     }     private final double[] accounts;     private Lock bankLock;     private Condition sufficientFunds;}/*** A runnable that transfers money from an account to other* accounts in a bank.*/class TransferRunnable implements Runnable{     /**     * Constructs a transfer runnable.     * @param b the bank between whose account money is transferred     * @param from the account to transfer money from     * @pram max the maximum amount of money in each transfer     */     public TransferRunnable(Bank b, int from, double max)     {          bank = b;          fromAccount = from;          maxAmount = max;     }     public void run()     {          try          {               while (true)               {                    int toAccount = (int) (bank.size() * Math.random());                    double amount = maxAmount * Math.random();                    bank.transfer(fromAccount, toAccount, amount);                    Thread.sleep((int) (DELAY * Math.random()));               }          }          catch (InterruptedException e) {}     }     private Bank bank;     private int fromAccount;     private double maxAmount;     private int repetitions;     private int DELAY = 10;}