定时任务
- 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;
}
}
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
