Java定时总结（Rx一行代码解决orz）

定时任务

• 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