《android开发-从小工到专家》学习记录（七）

对于Android平台来说，由于资源有限，最常使用的就是通过Executors.newFixedThreadPool(int size)函数来启动固定数量的线程，使用代码如下：

package zs;

import java.util.concurrent.Callable;
import java.util.concurrent.CancellationException;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

public class ABC {
private static void fixedThreadPool(int size)
throws CancellationException,ExecutionException, InterruptedException
{
ExecutorService executorService = Executors.newFixedThreadPool(size);
for(int i = 0;i < 10;i++)
{
Future<Integer> task = executorService.submit(new Callable<Integer>(){
@Override
public Integer call() throws Exception{
System.out.println("执行线程: "+Thread.currentThread().getName());
return add(50);
}
});
System.out.println("第"+i+"次计算，结果:"+task.get());
}
}
private static int add(int num)
{
int sum = 0;
for(int i = 0;i<num;i++)
{
sum = sum + num;
}
return sum;
}
public static void main(String[] args)
{
try{
fixedThreadPool(3);
}catch(Exception e)
{
e.printStackTrace();
}
}
}上述代码启动了一个含有3个线程的线程池，结果如下图：



结果中可以看出，线程池中一共有三个线程交替使用，完成了submit函数提交的十个任务。

有时候我们需要任务尽可能地快被执行，这就需要线程池中的线程足够多。也就是说此时需要使用空间来换时间，线程越多占用的内存消耗自然也就越大，但是，在正常情况下它的并发量也会更大，带来的是执行速度也越快，使用Executors的newCachedThreadPool函数可以实现---来了一个新任务，并且没有空闲线程可用，就马上创建一个线程来执行任务，使用代码如下：
package zs;

import java.util.concurrent.Callable;
import java.util.concurrent.CancellationException;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

public class ABC {
private static void fixedThreadPool(int size)
throws CancellationException,ExecutionException, InterruptedException
{
ExecutorService executorService = Executors.newCachedThreadPool();
for(int i = 0;i < 10;i++)
{
/*Future<Integer> task = executorService.submit(new Callable<Integer>(){
@Override
public Integer call() throws Exception{
System.out.println("执行线程: "+Thread.currentThread().getName());
return add(50);
}
});
System.out.println("第"+i+"次计算，结果:"+task.get());*/
executorService.submit(new Runnable(){
@Override
public void run()
{
System.out.println("执行线程: "+Thread.currentThread().getName()+"，结果:"+add(50));
}
});
}
}
private static int add(int num)
{
int sum = 0;
for(int i = 0;i<num;i++)
{
sum = sum + num;
}
return sum;
}
public static void main(String[] args)
{
try{
fixedThreadPool(3);
}catch(Exception e)
{
e.printStackTrace();
}
}
}
注意到不在使用task.get()获得返回值，get方法会阻塞线程，从而使结果不明显，大家可以自己试试看，使用Runnable得到的结果如下：



可以看到该线程池为每个任务都创建了一个线程。

我们还可以使用ScheduledThreadPoolExecutor进行执行定时任务，执行代码可以翻阅网上其他资料或者翻阅此书，我没有敲，就不贴出来了。

在开发的过程中我们会使用到同步集合和同步锁来完成程序：
CopyOnWriteArrayList是一种同步集合的实现，适用于读多写少的条件，写入的方法使用Copy-On-Write优化策略，先把列表中的元素复制一份，然后进行修改，修改完成之后再将新的元素设置给这个列表，使用的是一种延时懒惰策略，这样做的好处是我们可以对列表进行并发地读；
ConcurrentHashMap使用锁分离技术，解决了HashTable容器在竞争激烈的并发环境下效率低下的问题，HashTable效率低下的原因是在高并发环境下，所有访问线程都必须竞争同一把锁，而ConcurrentHashMap中有多把锁，每一把锁用于锁容器其中一部分数据，这样多线程访问不同段的时候，线程间就不会存在竞争；
BlockingQueue是一种生产者消费者的实现，队列满时put函数会将调用线程阻塞，直到队列不满，take函数如果队列为空时，同样将线程阻塞，直到队列中有元素。
下面使用同步锁实现一个BlockingQueue:
package zs;

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class MyArrayBlockingQueue<T> {
//数据数组
private final T[] items;
//锁
private final Lock lock = new ReentrantLock();
//队列满的条件
private Condition notFull = lock.newCondition();
//队列空的调节
private Condition notEmpty = lock.newCondition();
private int head;
private int tail;
//数据个数
private int count;
public MyArrayBlockingQueue(int maxSize)
{
items = (T[]) new Object[maxSize];
}
public MyArrayBlockingQueue()
{
this(10);
}
public void put(T t)
{
lock.lock();
try{
while(count == getCapacity())
{
System.out.println("数据已满，等待");
notFull.await();
}
items[tail] = t;
if(++tail == getCapacity())
{
tail = 0;
}
++count;
notEmpty.signalAll();
}catch(InterruptedException e)
{
e.printStackTrace();
}finally{
lock.unlock();
}
}
public T take()
{
lock.lock();
try{
while(count == 0)
{
System.out.println("暂无数据");
notEmpty.await();
}
T ret = items[head];
if(++head == getCapacity())
{
head = 0;
}
--count;
notFull.signalAll();
return ret;
}catch(InterruptedException e)
{
e.printStackTrace();
}finally{
lock.unlock();
}
return null;
}
public int getCapacity()
{
return items.length;
}
public int size()
{
lock.lock();
try{return count;}
finally{
lock.unlock();
}
}
public static void main(String[] args)
{
MyArrayBlockingQueue<Integer> aQueue
= new MyArrayBlockingQueue<Integer>();
aQueue.put(3);
aQueue.put(24);
for(int i = 0;i<5;i++)
{
System.out.println(aQueue.take());
}
}
}

ReentrantLock类有一个重要的函数，newCondition()，该函数用于获取Lock上的一个条件，Condition与Lock绑定，用于实现线程间的通信，具体使用方法见上述代码，需要注意的是lock必须在finally块中释放，否则如果受保护的代码会弹出异常，锁就永远得不到释放，会出现问题。