典型的工作线程结构
下面是典型的工作线程结构，注意中断监测和异常处理，并且在finally中做一些资源回收的工作。
1 /**
2 * 典型线程池工作者线程结构
3 */
4 public void run() {
5 Throwable thrown = null;
6 try {
7 while (!Thread.currentThread().isInterrupted()) {
8 // Run task...
9 }
10 } catch (Throwable e) {
11 thrown = e;
12 } finally {
13 // Exited the thread...
14 }
15 }
ReentrantLock
synchronized使用对象内置的监视器进行同步，这已经可以满足绝大多数的开发情况。如果你还需要更加灵活的锁，比如实现有时限的堵塞，或 者需要在无法获得锁的时候进行一些处理，那么你可以使用ReentrantLock。比如下面的tryLock方法，它在能够获取锁的时候返回true， 不能获取锁的时候返回false，而不会堵塞进程。
1 /** 2 * tryLock() 如果能够获得锁即获得锁并返回true,否则返回false 3 */ 4 public void tryLock() { 5 final int[] data = {0}; 6 ReentrantLock lock1 = new ReentrantLock(); 7 ReentrantLock lock2 = new ReentrantLock(); 8 9 Thread thread1 = new Thread(new Runnable() { 10 @Override 11 public void run() { 12 boolean tag = false; 13 for(int i = 0; i < 10; i++) { 14 try { 15 Thread.sleep(500); 16 } catch (InterruptedException e) { 17 e.printStackTrace(); 18 } 19 while (true) { 20 if (lock1.tryLock()) { 21 try { 22 if (lock2.tryLock()) { 23 try { 24 data[0]++; 25 System.out.println("++"); 26 tag = true; 27 } finally { 28 lock2.unlock(); 29 } 30 } 31 } finally { 32 lock1.unlock(); 33 } 34 } 35 36 if (tag) { 37 tag = false; 38 break; 39 } 40 } 41 } 42 } 43 }); 44 45 Thread thread2 = new Thread(new Runnable() { 46 @Override 47 public void run() { 48 boolean tag = false; 49 for(int i = 0; i < 10; i++) { 50 try { 51 Thread.sleep(400); 52 } catch (InterruptedException e) { 53 e.printStackTrace(); 54 } 55 while (true) { 56 if (lock2.tryLock()) { 57 try { 58 if (lock1.tryLock()) { 59 try { 60 data[0]--; 61 System.out.println("--"); 62 tag = true; 63 } finally { 64 lock1.unlock(); 65 } 66 } 67 } finally { 68 lock2.unlock(); 69 } 70 } 71 72 if (tag) { 73 tag = false; 74 break; 75 } 76 } 77 } 78 } 79 }); 80 81 thread1.start(); 82 thread2.start(); 83 84 try { 85 thread1.join(); 86 } catch (InterruptedException e) { 87 e.printStackTrace(); 88 } 89 try { 90 thread2.join(); 91 } catch (InterruptedException e) { 92 e.printStackTrace(); 93 } 94 95 System.out.println(data[0]); 96 } |
Condition
如果有两个条件谓词在同一个同步对象上使用wait()和notify()进行资源的堵塞等待，那么即有可能会发生信号的丢失，导致死锁。对于这种 情况，要么是用notifyAll()通知等待队列中的进程，这样效率会稍微低一些；另一种方法是使用锁的Condition，
1 /** 2 * Condition 3 */ 4 class ConditionBoundeBuffer<T> { 5 protected final Lock lock = new ReentrantLock(); 6 7 private final Condition notFull = lock.newCondition(); 8 private final Condition notEmpty = lock.newCondition(); 9 10 private final T[] items = (T[]) new Object[3]; 11 private int tail, head, count; 12 13 public void put(T x) throws InterruptedException { 14 lock.lock(); 15 try { 16 while (count == items.length) { 17 notEmpty.await(); 18 } 19 items[tail] = x; 20 if (++tail == items.length) 21 tail = 0; 22 ++count; 23 notEmpty.signal(); 24 } finally { 25 lock.unlock(); 26 } 27 } 28 29 public T take() throws InterruptedException { 30 lock.lock(); 31 try { 32 while (count == 0) { 33 notEmpty.await(); 34 } 35 T x = items[head]; 36 items[head] = null; 37 if (++head == items.length) { 38 head = 0; 39 } 40 --count; 41 notFull.signal(); 42 return x; 43 } finally { 44 lock.unlock(); 45 } 46 } 47 } |
