定时任务
- Rx
public class RxUtils {
static public Observable<Integer> countDown(int time) {
if (time < 0) time = 0;
final int countTime = time;
return Observable.interval(0, 1, TimeUnit.SECONDS)
.map(new Func1<Long, Integer>() {
@Override
public Integer call(Long increaseTime) {
return countTime - increaseTime.intValue();
}
})
.take(countTime + 1);
//
// Observable.timer(time,TimeUnit.SECONDS).filter(new Func1<Long, Boolean>() {
// @Override
// public Boolean call(Long aLong) {
// return null;
// }
// })
}
}
-
Timer
Timer timer = new Timer(); TimerTask timerTask = new TimerTask() { @Override public void run() { LogUtil.v("java", "任务开始"); } }; timer.schedule(timerTask, 1000); timer.schedule(timerTask, 1000); ps:timer.cancel; -
Handler
Handler handler = new Handler(); Runnable runnable = new Runnable() { @Override public void run() { LogUtil.v("java", "定时任务开启"); } }; handler.postDelayed(runnable, 1000); //handler.removeCallbacksAndMessages(null); -
AlarmManager
am = (AlarmManager) this.getSystemService(ALARM_SERVICE); Intent i = new Intent(this, UpdateReceiver.class); PendingIntent pendingIntent = PendingIntent.getBroadcast(this, 0, i, 0); //am.set(AlarmManager.RTC, System.currentTimeMillis() + 1000, pendingIntent); am.setRepeating(AlarmManager.ELAPSED_REALTIME_WAKEUP, SystemClock.elapsedRealtime(), 1000, pendingIntent);
锁机制
- 概念
- 原子性：只有一个线程能够执行这个代码
- 可见性： 保证前后修改的资源一致
- 分类
synchronized
-
ReentrantLock：可重入的意义在于持有锁的线程可以继续持有，并且要释放对等的次数后才真正释放该锁
class Outputter1 { private Lock lock = new ReentrantLock();// 锁对象 public void output(String name) { lock.lock(); // 得到锁 try { //do something } finally { lock.unlock();// 释放锁 } } } -
ReadWriteLock：可以同时读取，限制写入
class Data { private int data;// 共享数据 private ReadWriteLock rwl = new ReentrantReadWriteLock(); public void set(int data) { rwl.writeLock().lock();// 取到写锁 try { System.out.println(Thread.currentThread().getName() + "准备写入数据"); try { Thread.sleep(20); } catch (InterruptedException e) { e.printStackTrace(); } this.data = data; System.out.println(Thread.currentThread().getName() + "写入" + this.data); } finally { rwl.writeLock().unlock();// 释放写锁 } } public void get() { rwl.readLock().lock();// 取到读锁 try { System.out.println(Thread.currentThread().getName() + "准备读取数据"); try { Thread.sleep(20); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(Thread.currentThread().getName() + "读取" + this.data); } finally { rwl.readLock().unlock();// 释放读锁 } } } -
和Condition的结合
class BoundedBuffer { final Lock lock = new ReentrantLock();//锁对象 final Condition notFull = lock.newCondition();//写线程条件 final Condition notEmpty = lock.newCondition();//读线程条件 final Object[] items = new Object[100];//缓存队列 int putptr/*写索引*/, takeptr/*读索引*/, count/*队列中存在的数据个数*/; public void put(Object x) throws InterruptedException { lock.lock(); try { while (count == items.length)//如果队列满了 notFull.await();//阻塞写线程 items[putptr] = x;//赋值 if (++putptr == items.length) putptr = 0;//如果写索引写到队列的最后一个位置了，那么置为0 ++count;//个数++ notEmpty.signal();//唤醒读线程 } finally { lock.unlock(); } } public Object take() throws InterruptedException { lock.lock(); try { while (count == 0)//如果队列为空 notEmpty.await();//阻塞读线程 Object x = items[takeptr];//取值 if (++takeptr == items.length) takeptr = 0;//如果读索引读到队列的最后一个位置了，那么置为0 --count;//个数-- notFull.signal();//唤醒写线程 return x; } finally { lock.unlock(); } } }
多线程总结
-
管理类
-
基本
ExecutorService e = Executors.newCachedThreadPool(); ExecutorService e = Executors.newSingleThreadExecutor(); ExecutorService e = Executors.newFixedThreadPool(3); // 第一种是可变大小线程池，按照任务数来分配线程， // 第二种是单线程池，相当于FixedThreadPool(1) // 第三种是固定大小线程池。 // 然后运行 e.execute(new MyRunnableImpl()); -
定时任务线程
ScheduledExecutorService threadPools = Executors.newScheduledThreadPool(2); for(int i = 0; i < 2;i++){ threadPools.schedule(new Runnable() { @Override public void run() { System.out.println(Thread.currentThread().getName() + "定时器执行"); } }, 2, TimeUnit.SECONDS); } threadPools.shutdown(); //scheduleAtFixedRate 这个方法是不管你有没有执行完，反正我每隔4秒来执行一次，以相同的频率来执行 //scheduleWithFixedDelay 这个是等你方法执行完后，我再隔4秒来执行，也就是相对延迟后，以固定的频率去执行
-
Semaphore就是一个信号量，它的作用是限制某段代码块的并发数
-
FutureTask类实现了RunnableFuture接口，我们看一下RunnableFuture接口的实现，RunnableFuture继承了Runnable接口和Future接口，而FutureTask实现RunnableFuture接口。所以它既可以作为Runnable被线程执行，又可以作为Future得到Callable的返回值。
public class Test { public static void main(String[] args) { //第一种方式 ExecutorService executor = Executors.newCachedThreadPool(); Task task = new Task(); FutureTask<Integer> futureTask = new FutureTask<Integer>(task); executor.submit(futureTask); executor.shutdown(); //第二种方式，注意这种方式和第一种方式效果是类似的，只不过一个使用的是ExecutorService，一个使用的是Thread /*Task task = new Task(); FutureTask<Integer> futureTask = new FutureTask<Integer>(task); Thread thread = new Thread(futureTask); thread.start();*/ try { Thread.sleep(1000); } catch (InterruptedException e1) { e1.printStackTrace(); } System.out.println("主线程在执行任务"); try { System.out.println("task运行结果"+futureTask.get()); } catch (InterruptedException e) { e.printStackTrace(); } catch (ExecutionException e) { e.printStackTrace(); } System.out.println("所有任务执行完毕"); } } class Task implements Callable<Integer>{ @Override public Integer call() throws Exception { System.out.println("子线程在进行计算"); Thread.sleep(3000); int sum = 0; for(int i=0;i<100;i++) sum += i; return sum; } }
参考
- http://blog.csdn.net/dxpqxb/article/details/8659292
- http://blog.csdn.net/vking_wang/article/details/9952063
- http://www.jianshu.com/p/40d4c7aebd66 多线程
- http://mybar.iteye.com/blog/1829883 线程池
- http://www.cnblogs.com/dolphin0520/p/3949310.html Future
- http://blog.csdn.net/yaojiank/article/details/8888186
