Java基础笔记（14）多线程与同步机制、线程组、线程池以及相关问题
一、多线程
1.多线程：一个应用程序有多条执行路径
进程：正在执行的应用程序
线程：进程的执行单元，执行路径
单线程：一个应用程序只有一条执行路径
多线程：一个应用程序有多条执行路径
多进程的意义?
提高CPU的使用率
多线程的意义?
提高应用程序的使用率
2.多线程的实现方案
1)继承Thread类
2)实现Runnable接口
3.线程的调度和优先级问题
1)线程的调度
A:分时调度
B:抢占式调度 (Java采用的是该调度方式)
2)获取和设置线程优先级
A:默认是5 //Thread.NORM_PRIORITY
B:范围是1-10 //Thread.MIN_PRIORITY ~ Thread.MAX_PRIORITY
C:线程优先级仅仅表示优先级高的线程抢占CPU时间片的几率高，但是要在次数多或多次运行的情况才明显
4.线程的生命周期
5.线程的控制(5个常见方法)
休眠线程、加入线程、礼让线程、守护线程和终止线程。
1)休眠线程：sleep
Thread.sleep(1000); //休眠1秒，待休眠结束，线程进入就绪环节
2)加入线程：join
public class ThreadJoin extends Thread {
public ThreadJoin(){}
public ThreadJoin(String name){
super(name);
}
@Override
public void run() {
for(int i=0;i<100;i++){
System.out.println(getName()+"："+i);
}
}
public static void main(String[] args) {
ThreadJoin tj1 = new ThreadJoin("李渊");
ThreadJoin tj2 = new ThreadJoin("李建成");
ThreadJoin tj3 = new ThreadJoin("李世民");
tj1.start();
try {
//tj1线程走完才能走tj2和tj3（先有李渊，才有李建成和李世民）
tj1.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
tj2.start();
tj3.start();
}
} 3)礼让线程：yield
A:暂停当前正在执行的线程对象，并执行其它线程
B:让多个线程的执行更和谐，但不能保证多个线程交替执行
@Override
public void run() {
for(int i=0;i<100;i++){
System.out.println(getName()+"："+ i);
Thread.yield();
}
}4)守护线程（后台线程）：daemon
public static void main(String[] args) {
ThreadDaemon m1 = new ThreadDaemon("关羽");
ThreadDaemon m2 = new ThreadDaemon("张飞");
/*
* public final void setDaemon(boolean on)
* 将该线程标记为守护线程或用户线程。当正在运行的线程都是守护线程时，Java 虚拟机退出。
* 该方法必须在启动线程前调用。
*/
m1.setDaemon(true);
m2.setDaemon(true);
m1.start();
m2.start();
Thread.currentThread().setName("刘备");
for(int i=0;i<5;i++){
System.out.println(Thread.currentThread().getName()+"====="+i);
}
//主线程执行完，守护线程也即将消亡。
} 5)终止线程
A:stop —— 让线程停止，不再往下执行；已过时
B:interrupt —— 中断线程，把线程的状态终止，并抛出一个InterruptException
public class ThreadStop extends Thread {
private SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
public ThreadStop(){}
public ThreadStop(String name){
super(name);
}
@Override
public void run() {
System.out.println("线程启动..."+ format.format(new Date()));
//休眠6秒
try {
Thread.sleep(6000);
} catch (InterruptedException e) {
System.out.println("线程被中断...");
}
System.out.println("线程结束..."+ format.format(new Date()));
}
public static void main(String[] args) {
ThreadStop ts = new ThreadStop();
ts.start();
try {
Thread.sleep(3000);
//超过3秒中断
//ts.stop();
ts.interrupt();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
} 6.多线程安全问题的原因(也是我们以后判断一个程序是否有线程安全问题的依据)
1)是否是多线程环境
2)是否有共享数据
3)是否有多条语句操作共享数据
例子：电影院卖票程序出问题
A:为了更符合真实的场景，加入了休眠100毫秒。
B:卖票问题
a:同票多次
b:负数票
7.同步解决线程安全问题
加锁。
二、同步机制
1.同步的特点：
1)前提：多个线程
2)关键：多个线程共用一把锁
3)利弊好处：解决多线程的安全问题。
好处：解决多线程的安全问题。
弊端：当线程非常多时，因为每个线程都会去判断同步上的锁，这是很消耗资源的，无形中会降低程序的运行效率。
2.实现同步
1)synchronized关键字
A:同步代码块
synchronized(对象) {
//需要被同步的代码;
} 这里的锁对象可以是任意对象：
a:该对象为this，等同于B.a
public void test(){
synchronized(this){
}
}b:该对象为当前类的字节码文件对象（类.class），等同于B.b
public static void test(){
synchronized(类.class){
}
} 如果该对象是当前类的类变量，相当于类锁（但不等同类.class，因为对象不同），前提是不能改变其引用值，
因此一般会加final修饰。
B:同步方法
a:把同步加在成员方法上
这里的锁对象是this；不影响调用当前类的非同步方法。
b:把同步加在静态方法上（类锁）
这里的锁对象是当前类的字节码文件对象；不影响调用当前类的非同步方法。
A.b例子：
public class StaticDemo {
private static Object lock = new Object();
public synchronized static void fun() {//锁对象是类对象
while (true) {
System.out.println("in fun");
try {
TimeUnit.MILLISECONDS.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
public static void fun1() {//等同于fun
synchronized (StaticDemo.class) {
while (true) {
System.out.println("in fun1");
try {
TimeUnit.MILLISECONDS.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
public static void fun2() {//代码块。锁对象是lock对象
synchronized (lock) {
while (true) {
System.out.println("in fun2");
try {
TimeUnit.MILLISECONDS.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
public static void main(String[] args) {
new Thread(){
@Override
public void run() {
fun();
}
}.start();
new Thread(){
@Override
public void run() {
fun1();
}
}.start();
new Thread(){
@Override
public void run() {
fun2();
}
}.start();
/*
* 结果：fun()和fun2()交替进行，或者fun1()和fun2()交替进行
* 因为只要运行 fun(fun1) 的线程不交出锁，fun1（fun） 就无法被调用，因为他们都是共享了
* Class object（类对象） 的锁。
*/
}
} 2)Lock锁
JDK5以后的针对线程的锁定操作和释放操作。
1)常见语句
Lock lock = new ReentrantLock();//ReentrantLock是Lock接口的一个实现类
public void test(){
lock.lock();
try {
//需要同步的代码
} finally {
lock.unlock();
}
}效果等同于
synchronized(对象) {
//需要被同步的代码;
}2)方法
//基本
A:void lock() //获取锁
B:void unlock() //释放锁
C:Condition newCondition() //返回绑定到此 Lock 实例的新 Condition 实例
//其它
D:void lockInterruptibly() //如果当前线程未被中断，则获取锁
E:boolean tryLock() //仅在调用时锁为空闲状态才获取该锁
F:boolean tryLock(long time, TimeUnit unit) //如果锁在给定的等待时间内空闲，并且当前线程未被中断，则获取锁 3)相关类：Condition
Lock替代了synchronized方法和语句的使用，Condition替代了Object监视器方法（wait、notify 和 notifyAll）的使用。
A:void await() //接到信号或被中断前一直处于等待状态。等同于Object对象.wait()
B:boolean await(long time, TimeUnit unit) //与await()多了等待时间的设置
C:long awaitNanos(long nanosTimeout) //等待时间为纳秒
D:void awaitUninterruptibly() //接到信号前一直等待
E:boolean awaitUntil(Date deadline) //接到信号、被中断前或截止时间前一直等待
F:void signal() //唤醒一个等待线程。等同于Object对象.notify()
G:void signalAll() //唤醒所有等待线程。等同于Object对象.notifyAll() 3.死锁的产生
A等待B的锁，B等待A的锁，互相等待。
部分代码：
@Override
public void run() {
if(flag){
synchronized (MyLock.lockA) {
System.out.println("if lockA ");
synchronized (MyLock.lockB) {
System.out.println("if lockB ");
}
}
}else{
synchronized (MyLock.lockB) {
System.out.println("else lockB ");
synchronized (MyLock.lockA) {
System.out.println("else lockA ");
}
}
}
}
public static void main(String[] args) {
DeathLock d1 = new DeathLock(true);
DeathLock d2 = new DeathLock(false);
d1.start();
d2.start();
}4.生产者和消费者多线程体现(线程间通信问题)
三、线程组：ThreadGroup
默认的线程组是main线程组。
public static void defaultGroup(){
MyRunnable mr = new MyRunnable();
Thread t1 = new Thread(mr, "张三");
Thread t2 = new Thread(mr, "李四");
//在默认情况下，线程属于main线程组
System.out.println(t1.getThreadGroup().getName());
System.out.println(t2.getThreadGroup().getName());
//在默认情况下，所有线程属于同一个组
System.out.println(Thread.currentThread().getThreadGroup().getName());
}
public static void selfGroup(){
MyRunnable mr = new MyRunnable();
//定义一个线程组
ThreadGroup group = new ThreadGroup("全新的线程组");
Thread t1 = new Thread(group, mr, "张三");
Thread t2 = new Thread(group, mr, "李四");
System.out.println(t1.getThreadGroup().getName());
System.out.println(t2.getThreadGroup().getName());
//线程组可以对组内的线程进行统一操作
//group.setDaemon(true); //设置组内所有线程为守护线程
//group.interrupt(); //中断组内所有线程
}四、线程池
1.特点
1)统一管理线程
2)可重复利用工作线程，减少创建和销毁线程的开销
3)可有效控制系统的最大并发线程数
2.相关接口和类
1)基本接口
Executor
|--ExecutorService
|--ScheduledExecutorService
2)接口实现类
ThreadPoolExecutor（实现ExecutorService）
|--ScheduledThreadPoolExecutor（实现ScheduledExecutorService）
3)工具类
Executors
4)队列
Java并发包（java.util.concurrent ）中的阻塞队列共7个，都是线程安全的。
3.ThreadPoolExecutor类
构造方法之一：
public ThreadPoolExecutor(int corePoolSize,
int maximumPoolSize,
long keepAliveTime,
TimeUnit unit,
BlockingQueue workQueue)
//corePoolSize //池中所保存的线程数，包括空闲线程
//maximumPoolSize //池中允许的最大线程数
//keepAliveTime //当线程数大于corePoolSize时，此为终止前多余的空闲线程等待新任务的最长时间（活跃时间）
//unit //keepAliveTime的时间单位
//workQueue //执行前用于保持任务的队列。此队列仅保持由 execute 方法提交的 Runnable 任务。 1)newFixedThreadPool
//固定线程数的线程池
ExecutorService pool = Executors.newFixedThreadPool(nThreads);
//Executors源码
public static ExecutorService newFixedThreadPool(int nThreads) {
return new ThreadPoolExecutor(nThreads, nThreads,
0L, TimeUnit.MILLISECONDS,
new LinkedBlockingQueue());
} A:执行execute(Runnable)，即新增任务时：
a:池中线程数 < corePoolSize，创建新线程执行任务
b:池中线程数 >= corePoolSize，多出的任务进入无界队列（LinkedBlockingQueue）等待
B:队列中执行完的任务会被移除，执行该任务的线程变成空闲线程，可再执行队列中等待执行的任务
C:活跃时间为0L，即线程数大于corePoolSize时，多余的线程立即被终止
D:队列无界，可一直添加新任务
E:C,D,A.b ——> 线程池不会拒绝任务
2)newCachedThreadPool
//“无限”容量的线程池
ExecutorService pool = Executors.newCachedThreadPool();
//Executors源码
public static ExecutorService newCachedThreadPool() {
return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
60L, TimeUnit.SECONDS,
new SynchronousQueue());
} A:执行execute(Runnable)，即新增任务时：有空闲线程则利用，没有则创建新线程使用
B:corePoolSize为0，活跃时间为60秒，即空闲线程在60秒内没有任务执行将被回收
C:队列SynchronousQueue无容量
a:每个插入（offer）操作必须等待另一个线程的移除（poll）操作，
即offer时有空闲线程执行队列的poll，任务交由空闲线程执行
b:没有线程执行poll，则创建新线程
3)newSingleThreadExecutor
//单个工作线程的线程池
ExecutorService pool = Executors.newSingleThreadExecutor();
//Executors源码
public static ExecutorService newSingleThreadExecutor() {
return new FinalizableDelegatedExecutorService
(new ThreadPoolExecutor(1, 1,
0L, TimeUnit.MILLISECONDS,
new LinkedBlockingQueue()));
} A:执行效果基本与Executors.newFixedThreadPool(1)相同
B:按添加顺序执行任务
C:返回的对象不能强转为ThreadPoolExecutor类型
4.ScheduledThreadPoolExecutor类
构造方法之一：
public ScheduledThreadPoolExecutor(int corePoolSize)
corePoolSize - 池中所保存的线程数（包括空闲线程）
//源码
public ScheduledThreadPoolExecutor(int corePoolSize) {
super(corePoolSize, Integer.MAX_VALUE, 0, NANOSECONDS,
new DelayedWorkQueue());
}成员方法之一：
//周期性地执行任务
public ScheduledFuture scheduleAtFixedRate(Runnable command,
long initialDelay,
long period,
TimeUnit unit)
//command //要执行的任务
//initialDelay //首次执行的延迟时间
//period //连续执行之间的周期
//unit //initialDelay 和 period 参数的时间单位 1)newScheduledThreadPool
//可周期执行任务的线程池
ScheduledExecutorService pool = Executors.newScheduledThreadPool(corePoolSize);
等同于
ScheduledExecutorService pool = new ScheduledThreadPoolExecutor(corePoolSize);
A:可强转为ScheduledThreadPoolExecutor
B:
corePoolSize = 1，等待中的任务由同一个线程执行，执行哪个任务与任务周期有关
corePoolSize > 1，空闲的线程都有可能执行到等待中的任务，哪个空闲线程执行哪个任务
与任务周期和线程优先级（谁先抢到CPU时间片就是谁）有关
//部分代码
ScheduledExecutorService pool = Executors.newScheduledThreadPool(2);
//任务1
pool.scheduleAtFixedRate(new Runnable() {
@Override
public void run() {
System.out.println(Thread.currentThread().getName() + ":执行任务1");
try {
Thread.sleep(700);
} catch (InterruptedException e) {
/*
* 如果输出，说明任务在执行时被中断了
* 如果不输出：
* 1.在休眠结束但线程未结束的情况下任务被停止
* 2.线程已结束，任务等待中
*/
System.out.println(e.getMessage() + " === 执行中的线程被打断");
}
}
}, 500, 1500, TimeUnit.MILLISECONDS);
//任务2
pool.scheduleAtFixedRate(new Runnable() {
@Override
public void run() {
System.out.println(Thread.currentThread().getName() + ":执行任务2");
}
}, 500, 2500, TimeUnit.MILLISECONDS);
try {
Thread.sleep(8000);
} catch (InterruptedException e) {
e.printStackTrace();
}
//关闭线程池
//pool.shutdown();
System.out.println("等待执行的任务数量：" + pool.shutdownNow().size());//1或2
2)newSingleThreadScheduledExecutor
ScheduledExecutorService pool = Executors.newSingleThreadScheduledExecutor();
//源码
public static ScheduledExecutorService newSingleThreadScheduledExecutor() {
return new DelegatedScheduledExecutorService
(new ScheduledThreadPoolExecutor(1));
} A:执行效果基本与Executors.newScheduledThreadPool(1)相同
B:返回的对象不能强转为ScheduledThreadPoolExecutor类型
五、线程相关问题
1.多线程有几种实现方案，分别是哪几种？
两种。
继承Thread类；
实现Runnable接口。
扩展一种：实现Callable接口，需要线程池结合。
2.同步有几种方式，分别是什么？
两种。
同步代码块；
同步方法。
3.启动一个线程是run()还是start()？它们的区别？
start();
run():封装了被线程执行的代码，直接调用仅仅是普通方法的调用
start():启动线程，并由JVM自动调用run()方法
4.Java程序的运行原理及JVM的启动是多线程的吗?
1)Java命令去启动JVM，JVM会启动一个进程，该进程会启动一个主线程。
2)JVM的启动是多线程的，因为它最低有两个线程启动，主线程和垃圾回收线程。
5.sleep()和wait()方法的区别
sleep()：必须指定时间；不释放锁。
wait()：有两个同名方法，可以指定时间，也可以不指定时间；释放锁。
6.为什么wait()、notify()、notifyAll()等方法都定义在Object类中
因为这些方法的调用是依赖于锁对象的，而同步代码块的锁对象是任意锁，
且Object表示任意的对象，所以定义在Object中。
结构思路与部分内容整理自传智。