进程和线程
操作系统中运?多个软件
1.?个运?中的软件可能包含多个进程
2.?个运?中的进程可能包含多个线程CPU 线程和操作系统线程
CPU 线程
多核 CPU 的每个核各?独?运?，因此每个核?个线程
「四核?线程」：CPU 硬件?在硬件级别对 CPU 进?了?核多线程的?持（本质上依然是每个核?个线程）操作系统线程：操作系统利?时间分?的?式，把 CPU 的运?拆分给多条运?逻辑，即为操作系统的线程单核 CPU 也可以运?多线程操作系统
线程是什么：按代码顺序执?下来，执?完毕就结束的?条线
UI 线程为什么不会结束？因为它在初始化完毕后会执?死循环，循环的内容是刷新界?
多线程的使?
-
Thread
Thread thread = new Thread() {
@Override
public void run() {
System.out.println("Thread started!");
}
};
thread.start();
-
Runnable
Runnable runnable = new Runnable() {
@Override
public void run() {
System.out.println("Thread with Runnable started!");
}
};
Thread thread = new Thread(runnable);
thread.start();
-
ThreadFactory
ThreadFactory factory = 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() + "
started!");
}
};
Thread thread = factory.newThread(runnable);
thread.start();
Thread thread1 = factory.newThread(runnable);
thread1.start();
Executor 和线程池
- newCachedThreadPool()
Runnable runnable = new Runnable() {
@Override
public void run() {
System.out.println("Thread with Runnable started!");
}
};
Executor executor = Executors.newCachedThreadPool();
executor.execute(runnable);
executor.execute(runnable);
executor.execute(runnable);
- 短时批量处理： newFixedThreadPool()
ExecutorService executor = Executors.newFixedThreadPool(20);
for (Bitmap bitmap : bitmaps) {
executor.execute(bitmapProcessor(bitmap));
}
executor.shutdown();
- Callable 和 Future
Callable<String> callable = new Callable<String>() {
@Override
public String call() {
try {
Thread.sleep(1500);
} catch (InterruptedException e) {
e.printStackTrace();
}
return "Done!";
}
};
ExecutorService executor = Executors.newCachedThreadPool();
Future<String> future = executor.submit(callable);
try {
String result = future.get();
System.out.println("result: " + result);
} catch (InterruptedException | ExecutionException e) {
e.printStackTrace();
}
线程同步与线程安全
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 (monitor1) {
synchronized (monitor2) {
name = x + "-" + y;
}
}
-
synchronized 的本质
保证?法内部或代码块内部资源（数据）的互斥访问。即同?时间、由同?个
Monitor 监视的代码，最多只能有?个线程在访问
image.png
保证线程之间对监视资源的数据同步。即，任何线程在获取到 Monitor 后的第?时
间，会先将共享内存中的数据复制到??的缓存中；任何线程在释放 Monitor 的第?
时间，会先将缓存中的数据复制到共享内存中。
image.png - volatile
1.保证加了 volatile 关键字的字段的操作具有原?性和同步性，其中原?性相当于实现了针对
2.单?字段的线程间互斥访问。因此 volatile 可以看做是简化版的 synchronized。
volatile 只对基本类型 (byte、char、short、int、long、float、double、boolean) 的赋值
操作和对象的引?赋值操作有效。 - java.util.concurrent.atomic 包
下?有 AtomicInteger AtomicBoolean 等类，作?和 volatile 基本?致，可以看做是通?版的 volatile。 - Lock / ReentrantReadWriteLock
同样是「加锁」机制。但使??式更灵活，同时也更麻烦?些。
Lock lock = new ReentrantLock();
...
lock.lock();
try {
x++;
} finally {
lock.unlock();
}
finally 的作?：保证在?法提前结束或出现 Exception 的时候，依然能正常释放锁
?般并不会只是使? Lock ，?是会使?更复杂的锁，例如 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();
}
}
线程安全问题的本质：
在多个线程访问共同的资源时，在某?个线程对资源进?写操作的中途（写?已经开始，但还没结束），其他线程对这个写了?半的资源进?了读操作，或者基于这个写了?半的资源进?了写操作，导致出现数据错误。锁机制的本质：
通过对共享资源进?访问限制，让同?时间只有?个线程可以访问资源，保证了数据的准确性。不论是线程安全问题，还是针对线程安全问题所衍?出的锁机制，它们的核?都在于共享的资 源，?不是某个?法或者某??代码。
