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

定时任务

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;
    }
}

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

定时任务

锁机制

多线程总结

参考

测试人员都是画画大神，让我看看谁还不会用代码图？

Object.values()对象遍历

Java定時總結（Rx一行代碼解決orz）

View的繪製流程簡述

Tinker 處理patch流程

StateMachine 的簡單使用

【持續更新】adb常用命令

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結