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.生产者和消费者多线程体现(线程间通信问题)
默认的线程组是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中。
结构思路与部分内容整理自传智。