线程和进程
进程和线程
操作系统中运行的多个软件，一个软件相当于一个进程(进程间的数据不共享)
一个运行中的软件可能包含多个进程(android:multiprocess/android:process)
一个运行中的进程可能包含多个线程(线程间的部分数据可以共享)
CPU线程和操作系统线程
CPU线程：
多核CPU的每个核各自独立运行，因此每个核一个线程
四核八线程：CPU硬件方在硬件级别对CPU进行了一核多线程的支持(本质上依然是每个核一个线程)
操作系统线程：
- 操作系统利用时间分片的方式，把CPU的运行拆分给多条运行逻辑，即为操作系统的线程
单核CPU也可以利用时间分片方式运行多线程操作系统
线程是什么
按代码顺序执行下来，执行完毕就结束的一条线
UI线程为什么不会结束？因为它在初始化完毕后悔执行死循环，循环的内容是刷线界面
多线程的使用
Thread
Thread thread = new Thread() { @Override public void run() { super.run(); //执行Runnable的run()方法 System.out.println("Thread start"); } }; thread.start();
Runnable
Thread thread = new Thread(new Runnable() { @Override public void run() { System.out.println("Thread with runnable start"); } }); thread.start();
ThreadFactory
ThreadFactory threadFactory = new ThreadFactory() { int count = 0; //线程安全问题 @Override public Thread newThread(Runnable r) { count++; return new Thread(r, "Thread-" + count); } }; Runnable runnable = new Runnable() { @Override public void run() { System.out.println(Thread.currentThread().getName() + " start"); } }; threadFactory.newThread(runnable).start(); threadFactory.newThread(runnable).start(); threadFactory.newThread(runnable).start();
Executor线程池
Executors.newCachedThreadPool() 常用带缓存的线程池
Executors.newFixedThreadPool(20) 短时批量处理线程池，加快处理速度
Executors.newSingleThreadExecutor() 单个线程的线程池
Executors.newSingleThreadScheduledExecutor() 具有定时功能的单线程线程池
Executors.newScheduledThreadPool(20) 具有定时功能的线程池
Runnable runnable = new Runnable() { @Override public void run() { System.out.println(Thread.currentThread().getName()); } }; ExecutorService executorService = Executors.newCachedThreadPool(); executorService.execute(runnable); executorService.execute(runnable); executorService.execute(runnable); executorService.shutdown();
Callable和Future
- 带返回值的线程，获取返回值时会阻塞当前线程，但是可以用while轮询去做其他事
Callable<String> callable = new Callable<String>() { @Override public String call() throws Exception { try { Thread.sleep(1500); } catch (InterruptedException e) { e.printStackTrace(); } return "Done"; } }; ExecutorService executorService = Executors.newCachedThreadPool(); Future<String> future = executorService.submit(callable); try { String result = future.get(); System.out.println("result = " + result); } catch (ExecutionException | InterruptedException e) { e.printStackTrace(); } finally { executorService.shutdown(); }
线程同步与线程安全
synchronized
- synchronized方法(该方法互斥访问)
private synchronized void count(int newValue) { x = newValue; y = newValue; if (x != y) { System.out.println("x = " + x + ", y = " + y); } }
- synchronized代码块(该代码块互斥访问)
private void count(int newValue) { synchronized (this){ x = newValue; y = newValue; } if (x != y) { System.out.println("x = " + x + ", y = " + y); } }
- synchronized静态方法(该类互斥访问)
public static synchronized void count(int newValue) { x = newValue; y = newValue; if (x != y) { System.out.println("x = " + x + ", y = " + y); } }
- synchronized 的本质
- 保证方法内部或代码块内部的资源(数据)的互斥访问。即同一时间，由同一个Monitor监视的代码，最多只能有一个线程在访问
- 保证线程之间对监视资源的数据同步。即任何线程在获取到Monitor后的第一时间，会先将共享内存中的数据复制到自己的缓存中；任何线程在释放Monitor的第一时间，会先将缓存中的数据复制到共享内存中
volatile
保证加了
volatile关键字的字段的操作具有同步性，以及对long和double的操作的原子性。因此volatile可以看做简化版的synchronizedvolatile只对基本类型(byte,char,short,int,long,float,double,boolean)的赋值操作和对象的引用赋值操作有效，但你若要修改
User.name是不能保证同步的volatile依然解决不了
++的原子性问题
java.util.concurrent.atomic包
- 里面有
AtomicInteger，AtomicBoolean等类，作用和volatile基本一致，可以看做是通用版的 volatile
AtomicInteger num = new AtomicInteger(0); ...... num.getAndIncrement();
Lock & ReentrantReadWriteLock
- 同样是加锁机制，但使用方式更灵活，同时也更麻烦一些
Lock lock = new ReentrantLock(); ...... lock.lock(); try { x++; } finally{ //保证在方法在提前结束或出现Exception的时候，依然能正常释放锁 lock.unlock(); }
- 一般会使用更加复杂的锁，例如
ReadWriteLock
ReentrantReadWriteLock lock = new ReentrantReadWriteLock(); Lock readLock = lock.readLock(); Lock writeLock = lock.writeLock(); private int x = 0; /*** 写操作加锁 */ private void count(){ writeLock.lock(); try { x++; } finally{ writeLock.unlock(); } } /*** 读操作加锁 */ private void print (int time) { readLock.lock(); try{ for (int i = 0; i< time; i++){ System.out.print(x + " "); } System.out.println(); } finally { readLock.unlock(); } }
线程安全问题的本质
在多个线程访问共同的资源时，在某一个线程对资源进行写操作的途中(写操作已经开始，但是还没有结束)，其它线程对这个写入了一半的资源进行了读操作，或者基于这个写了一半的资源进行了写操作，导致出现数据错误
锁机制的本质
通过对共享资源进行访问限制，让同一时间只有一个线程可以访问资源，保证了数据的准确性
不论是线程安全问题，还是针对线程安全问题所衍生出的锁机制，它们的核心都在于共享的资源，而不是某个方法或者某几行代码
