学习笔记

activity的构成

activity通过phonewindow对象去管理视图View。

activity的启动模式

• standard
• singleTop:在栈顶，不重建；不在栈顶，会重建
• singleTask:栈中只有一个；如果已经存在栈中，会销毁在它上面的所有activity，最终让他自己处于栈顶。
• singleInstance:系统级别只有一个单例。不同的栈去启动它，都只有一个，与其他三种不同

service

• service默认也是运行在UI线程中，不能做耗时操作，除非开辟新的子线程。
• 前台服务一般不会被回收，startForground.

IntentService

• IntentService将用户请求执行在 一个子线程中，用户只需要复写onHandleIntent，并且在该函数完
• 自己耗时操作即可。在任务执行完毕后，IntentService会调用stopself自我销毁。

同步集合

• 程序中的优化策略：CopyOnWriteArrayList,空间换时间；写的时候会加锁，读的时候不需要加锁。
• 提高并发效率：ConcurrentHasMap. HasMap是并发安全的，使用synchronize来保证线程安全，但是在线程竞争激烈的情况，效率非常低下，因为所有的线程都要争同一把锁。ConcurrentHasMap则将数据分段，分别分配不同的锁，效率得到提升。
• 有效的方法：BlockingQuene,顾名思义，阻塞队列，队列满时，添加数据的时候线程会阻塞，直到队列不是填满状态。

同步锁

• 同步机制的关键字：synchronized
  作用于对象，函数，class。每个对象只有一个锁，谁拿到了这个锁谁就有访问权限。

public class SynchronizedDemo{
    //同步方法，同步对象
    public synchronized void syncMethod(){
    }
    //同步代码块，同步对象
    public void syscThis{
        synchronized(this){
        }
    }
    //同步代码块，同步class对象
    public void syncClassMethod{
        synchronzed(SynchronizedDemo.class){
        }
    }
    //同步静态方法，同步class对象
    public synchronzied static void syscStaticMethod{
    }
}

• 显示锁：ReentrantLock 和 Condition
  与synchronize相比，具有更高的灵活性。
  
  1. 获取和释放的灵活性。
  2. 轮训锁和定时锁
  3. 公平性

函数	作用
lock()	获取锁
tryLock()	尝试获取锁
tryLock(long timeout, TimeUnit unit)	指定时间获取不到超时
unlock()	释放锁
newCondition()	获取锁的Condition

lock和unlock一定成对出现，切不可忘记unlock。

Lock lock = new ReentrantLock();
public void doSth(){
    lock.lock();
    try{
    }finally{
       lock.unlock();
    }
}

Condition为线程提供了一个含义，以便在某个状态条件现在可能为true的另一个线程通知他之前，一直挂起该线程。

函数	作用
await()	线程等待
await(int time, TimeUnit unit)	指定等待时间，否则超时
signal()	随机唤醒某个线程等待
signalAll()	唤醒所有等待中的线程

可以通过ReentrantLock与Condition来实现一个简单的阻塞队列。

private final Lock lock = new Lock();
private Condition notFull = lock.newCondition();
private Condition notEmpty = lock.newCondition();
...
public void put(T t){
    lock.lock();
    try{
        while(count == FULL){
            notFull.await();//等待不满，使得调用线程阻塞
        }
    }finally{
    lock.unlock()
    }
    items[tail]= t;
    notEmpty.signalAll();唤醒等待数据的线程
}

public T take(){
    while(count == 0){
        notEmpty.await();//等待数据添加进来，使得调用线程阻塞
    }
    notFull.signalAll();//唤醒添加数据的线程
}

信号量Semaphore

Semaphore是一个计数信号量，本质是一个共享锁。线程通过acquire来获取信号量的许可，通过release()来释放它所持有的信号量许可。

public class SemphoreDemo{
    public static void main(string[] args){
        final ExecutorService executor = Executors.newFixedThreadPool(3);
        final Semphore semphore = new Semphore(3);
        for(int i = 0; i < 5; i++){
            executor.submit(new Runnable(){
                @Overrid
                public void run(){
                    try{
                        semphore.acquire();
                        system.out.printlin("剩余许可"+semphore.availablePermits());
                        Thread.sleep(1000);
                        semphonre.release();
                    }

                }
            });
        }
    }
}
剩余许可 2
剩余许可 0
剩余许可 1//立刻输出，消费线程5，许可只有3.
//1s后才输出
剩余许可 1
剩余许可 2