多线程
一.概述
什么是程序?
- 程序是为特定任务,用某种语言编写的一组指令的集合.
- 指一段静态的代码,静态对象.
什么是进程?
- 进程是程序的一次执行过程,或者是正在运行的一个程序.
- 是一个动态的过程:有它自身的产生,存在和消亡的过程.---- 生命周期!
- 进程作为系统资源分配的单位,系统在运行时会为每个进程分配不同的内存区域.
- 内存区域包括:方法区和堆
什么是线程?
- 进程可以细化为线程
- 线程是一个程序内部的一条执行路径.
- 如果一个进程同一时间并行执行多个线程,我们就称是多线程的.
- 线程作为调度和执行的单位,每个线程拥有独立的运行栈(虚拟机栈)和程序计数器(pc)
- 线程切换的开销小
- 一个进程中的多个线程共享这个进程的内存单元/内存地址(调用同一个内存地址,共用一组方法区和堆),多线程从同一堆中分配对象,可以访问相同的变量和对象.这就使得线程间通信更简单,高效.但多个线程操作共享的系统资源就可能会带来安全隐患.
单核CPU
- 其实是一种假的多线程,宏观上看,因为CPU处理速度快,感觉不出来,实际上在一个时间单元内,只能执行一个线程.
多核CPU
- 更好的发挥多线程的效率,可以同时执行多个线程.
- 一个Java应用程序java.exe,至少有三个线程
- main()的主线程,GC()垃圾回收线程,异常处理线程.当然如果发生异常,会影响主线程.
并行
- 多个CPU同时执行多个任务.多个人同时做不同的事.
并发
- 一个CPU同时执行多个任务,假的多线程,多个人做同一件事,比如:秒杀
多线程的优点
- 提高引应用程序的响应.
- 提高计算机系统CPU的利用率.
- 改善程序结构.将既长又复杂的进程分为多个线程,独立运行,便于理解和修改.
应用场景
- 程序需要同时执行多个任务.
- 程序需要实现一些需要等待的任务时,如用户输入,文件读写操作,网络操作,搜索等.
- 需要一些后台运行的程序时.
二.多线程的创建
方式一:继承于Thread类
- 创建一个继承Thread类的子类
- 重写run()方法
- 在main()创建子类的对象
- 通过此对象调用start()方法
start():①启动当前线程②调用当前线程的run()
- 问题一:我们不能通过直接调用run()的方式来启动线程.
- 问题二:不可以让已经start()的线程再去执行.会报错:IllegalThreadStateException();可以重新new一个对象,用新的对象去start().
package com.zzb;
/**
* 遍历100以内的偶数
*/
class MyThread extends Thread {
@Override
public void run() {
for (int i = 0; i < 100; i++) {
if (i % 2 == 0) {
System.out.println(Thread.currentThread().getName() + " i = " + i);
}
}
}
}
public class ThreadTest {
public static void main(String[] args) {
MyThread myThread = new MyThread();
myThread.start();//线程一
new Thread() {//线程二:创建Thread类的匿名子类
@Override
public void run() {
for (int i = 0; i < 100; i++) {
if (i % 2 == 1) {
System.out.println(Thread.currentThread().getName() + " i = " + i);
}
}
}
}.start();
// myThread.start();//问题二
System.out.println("myThread = " + myThread);
}
}
方式二:实现Runnable接口
- 创建一个实现了Runnable接口的类
- 实现类实现接口中的抽象方法:run()
- 创建实现类的对象
- 将此对象作为参数传递到Thread类的构造器中,创建Thread对象
- 通过Thread类的对象调用start()方法
package com.zzb;
class TwoThread implements Runnable {
@Override
public void run() {
for (int i = 0; i < 100; i++) {
if (i % 2 == 0) {
System.out.println(Thread.currentThread().getName() + i);
}
if (i % 20 == 0) {
Thread.yield();
}
}
}
}
public class ThreadTestTwo {
public static void main(String[] args) throws InterruptedException {
TwoThread twoThread = new TwoThread();
Thread thread = new Thread(twoThread);
thread.setName("线程1 ");
thread.setPriority(10);
thread.start();
Thread thread2 = new Thread(twoThread);
thread2.setName("线程2 ");
thread2.setPriority(2);
thread2.start();
System.out.println(thread2.isAlive());
System.out.println(thread.isAlive());
}
}
- 练习
package com.zzb;
//创建三个窗口卖票,总票数100张,使用Runnable接口实现
//存在线程安全问题,待解决
class Window implements Runnable {
private int ticket = 100;
@Override
public void run() {
while (true) {
if (ticket > 0) {
System.out.println(Thread.currentThread().getName() + ":卖票,票号为: " + ticket);
ticket--;
} else {
break;
}
}
}
}
public class TicketTest {
public static void main(String[] args) {
Window window = new Window();//只new了一个对象
//以下是同一个对象里的ticket
Thread thread1 = new Thread(window);
Thread thread2 = new Thread(window);
Thread thread3 = new Thread(window);
thread1.setName("窗口1");
thread2.setName("窗口2");
thread3.setName("窗口3");
thread1.start();
thread2.start();
thread3.start();
}
}
两种创建线程方式的对比
- 开发中:优先选择:实现Runnable接口的方式.
- 原因:①实现的方式没有类的单继承性的局限性②实现的方式更适合来处理多个线程有共享数据的情况.
- 联系:public class Thread implements Runnable Thread类实现了Runnable接口
- 相同点:两种方式都需要重写run(),将线程要执行的逻辑声明在run()方法中.
三.Thread类的常用方法
常用方法
- 构造方法
-
start():启动当前线程,调用当前线程的run()
-
run():需要重写Thread类中的此方法,将创建的线程要执行的操作声明在此方法中
-
currentThread() : 静态方法,Thread类名直接调用,返回执行当前代码的线程.
-
getName():获取当前线程的名字
-
setName():设置当前线程的名字
-
yield(): 释放当前CPU的执行权
-
join():在线程a中调用线程b的join(),此时线程a就进入阻塞状态,直到线程b完全执行完以后,线程a才结束阻塞状态.等待该线程终止。
-
stop():已过时,不推荐使用.当执行此方法时,强制结束当前线程.
-
sleep(long millis) :只能trycatch,不能抛出,Thread类的run()方法没有抛出, 让当前线程睡眠(阻塞)指定的毫秒数,在指定的毫秒时间内,当前线程是阻塞状态.
-
isAlive() : 判断当前线程是否存活.(测试线程是否处于活动状态。)
线程的调度
- 调度策略:①时间片②抢占式:高优先级的线程抢占CPU
- java的调度方法:
- 同优先级线程组成先进先出队列(先到先服务),采用时间片策略.
- 对高优先级,采用优先调度的抢占式策略.
线程的优先级
- 优先级等级:共10级.
- MAX_PRIORITY:10(最大优先级)
- MIN_PRIORITY:1(最小优先级)
- NORM_PRIORITY:5(默认优先级)
线程的优先级相关方法
- getPriority()
返回线程的优先级。(获取) - setPriority(int newPriority)
更改线程的优先级。(设置)
- 说明:高优先级的线程要抢占低优先级线程CPU的执行权,但是,只是从概率上讲,高优先级的线程高概率的情况下被执行,并不意味着只有当高优先级的线程执行完以后低优先级的线程才执行.
四.线程的生命周期
Thread.State类
- JDK中用Thread.State类定义了线程的几种状态
- state是Thread类的内部类
- state是一个枚举类
线程的几种状态
- 新建:当一个Thread类或其子类的对象被声明创建时,新生的线程对象处于新建状态.new的时候
- 就绪:可运行的Runnable,处于新建状态的线程被start()后,将进入线程队列等待CPU时间片,此时它已经具备了运行的条件,只是还没有分配到CPU资源,等待被调用
- 运行:当就绪的线程被调用并获得CPU资源时,就进入了运行状态,run()方法定义了线程的操作和功能.
- 阻塞:在某种特殊情况下,被人为挂起或执行输入输出操作时,让出CPU并临时中止自己的执行,进入阻塞状态.
- 死亡:线程完成了它的全部工作或线程被提前强制性的中止或出现异常导致结束.
从运行到死亡的三种情况
- 执行完run()方法
- 调用线程的stop()方法
- 出现Error/Exception且没有处理
从运行到阻塞到就绪到运行的几种情况
- sleep(long time):睡眠结束,自动进入就绪状态
- join():等待该线程终止,进入就绪状态
- 等待同步锁:获取同步锁进入就绪状态
- wait():等待被唤醒,notify()/notifyAll()
- suspend():已过时,挂起,本方法可能会导致死锁.resume()结束挂起状态. 两个成对使用.
五.线程的同步
问题的提出
-
多个线程执行的不确定性引起执行结果的不稳定
-
多个线程对资源的共享,会造成操作的不完整性,会破坏数据.
-
比如:单例模式懒汉式存在线程安全问题在new这个唯一对象的时候.
通过同步机制,解决线程安全问题
方式一:同步代码块
- 关键字synchronized
- 操作共享数据的代码,即为需要被同步的代码
- 共享数据:多个线程共同操作的变量.
- 同步监视器,俗称:锁.任何类的对象,都可以充当锁.
要求:多个线程必须要共用同一把锁.当前对象this作为锁,不需要重新new其他对象.(实现Runnable接口的方式)
在继承子类中用:类.class作为锁 - 大括号里的代码不能包多了,也不能包少了,都可能导致错误.
synchronized(同步监视器){
//操作共享数据的代码
}
方式二:同步方法
- 如果操作共享数据的代码完整的声明在一个方法中,我们不妨将此方法声明为同步的.
- 在继承子类中,需要把方法加上static,同时在sout输出语句中用Thread.currentThread() .getName()
- 总结:
- 同步方法仍然涉及到同步监视器,只是不需要我们显示的声明.
- 非静态的同步方法,同步监视器是this
静态的同步方法,同步监视器是:当前类本身
同步方法解决实现Runnable()接口的线程安全问题
@Override
public void run() {
show();
}
private synchronized void show() {
while (true) {
if (ticket > 0) {
try {
Thread.sleep(50);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + ":卖票,票号为: " + ticket);
ticket--;
} else {
break;
}
}
}
用线程同步解决懒汉式的线程安全问题
package com.zzb;
public class SingletonTest {
}
class Person {
private Person() {
}
private static Person instance;
// public static synchronized Person getInstance() {
public static Person getInstance() {
//方式一:效率低
// synchronized (Person.class) {
// if (instance == null) {
// instance = new Person();
// }
// }
// return instance;
//方式二:效率稍高
if (instance == null) {
synchronized (Person.class) {
if (instance == null) {
instance = new Person();
}
}
}
return instance;
}
}
同步的优缺点
- 解决了线程的安全问题----优点
- 操作同步代码时,只能有一个线程参与,其他线程等待.相当于是一个单线程的过程.效率低.----局限性
死锁
- 不同的线程分别占用对方需要的同步资源不放弃,都在等待对方放弃自己需要的同步资源,就形成了线程的死锁.
- 解决方法:
- 专门的算法,原则
- 尽量减少同步资源的定义
- 尽量避免嵌套同步
- 出现死锁后,不会出现异常,不会出现提示,只是所有的线程都属于阻塞状态,无法继续
- 我们使用同步时,要避免出现死锁.
package com.zzb;
/**
* 死锁举例
*/
public class ThreadTest01 {
public static void main(String[] args) {
StringBuffer s1 = new StringBuffer();
StringBuffer s2 = new StringBuffer();
new Thread() {
@Override
public void run() {
synchronized (s1) {
s1.append("a");
s2.append("1");
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
synchronized (s2) {
s1.append("b");
s2.append("2");
System.out.println("s1 = " + s1);
System.out.println("s2 = " + s2);
}
}
}
}.start();
new Thread(new Runnable() {
@Override
public void run() {
synchronized (s2) {
s1.append("c");
s2.append("3");
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
synchronized (s1) {
s1.append("d");
s2.append("4");
System.out.println("s1 = " + s1);
System.out.println("s2 = " + s2);
}
}
}
}).start();
}
}
Lock(锁)
解决线程安全问题的方式三:Lock锁----JDK5.0新增
- 实例化ReentrantLock
- 使用try{lock.lock(); }finally{lock.unlock(); }
package com.zzb;
import java.util.concurrent.locks.ReentrantLock;
public class LockTest {
public static void main(String[] args) {
LockDemo lockDemo = new LockDemo();
Thread thread1 = new Thread(lockDemo);
Thread thread2 = new Thread(lockDemo);
Thread thread3 = new Thread(lockDemo);
thread1.setName("窗口1");
thread2.setName("窗口2");
thread3.setName("窗口3");
thread2.start();
thread1.start();
thread3.start();
}
}
class LockDemo implements Runnable {
private int ticket = 100;
private ReentrantLock lock = new ReentrantLock();
@Override
public void run() {
try {
lock.lock();
while (true) {
if (ticket > 0) {
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + ":售票,票号为: " + ticket);
ticket--;
} else {
break;
}
}
} finally {
lock.unlock();
}
}
}
- 面试题:synchronized和Lock的区别
- 相同:二者都可以解决线程安全的问题
- 不同:synchronized机制在执行完相应的同步代码以后,自动的释放同步监视器
Lock需要手动的启动同步(Lock()),同时结束同步也需要手动的实现(unlock())
- 优先使用顺序:
Lock→同步代码块(已经进入了方法体,分配了相应资源)→同步方法(在方法体之外)
六.线程的通信
wait()和notify()和notifyAll()
- wait(): 一旦执行此方法,当前线程进入阻塞状态,并释放锁(同步监视器).
- notify(): 一旦执行此方法,就会唤醒被wait的一个线程,如果有多个线程被wait,就唤醒优先级高的那个.
- notifyAll(): 一旦执行此方法,就会唤醒所有被wait的线程.
- 说明:
- wait(),notify(),notifyAll()三个方法必须使用在同步代码块或同步方法中.
- 三个方法的调用者必须是同步代码块或同步方法中的同步监视器,否则会出现异常
- 这三个方法是定义在java.long.Object类中的.
package com.zzb;
class Number implements Runnable {
private int num = 1;
@Override
public void run() {
while (true) {
synchronized (this) {
notify();
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
if (num <= 100) {
System.out.println(Thread.currentThread().getName() + ":" + num);
num++;
try {
wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
} else {
break;
}
}
}
}
}
public class CommunicationTest {
public static void main(String[] args) {
Number number = new Number();
Thread thread1 = new Thread(number);
Thread thread2 = new Thread(number);
thread1.setName("线程一");
thread2.setName("线程二");
thread1.start();
thread2.start();
}
}
七.JDK5.0新增线程创建方式
新增方式一:实现Callable接口
- 与使用Runable相比,Callable功能更强大
- 相比run()方法,call()方法可以有返回值
- 方法可以抛出异常
- 支持泛型的返回值
- 需要借助FutureTask类,比如获取返回值结果
package CallableTest;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
//1.创建Callable的实现类
class NumThread implements Callable {
//2.重写call方法
@Override
public Object call() throws Exception {
int sum = 0;
for (int i = 0; i <= 100; i++) {
if (i % 2 == 0) {
System.out.println("i = " + i);
sum += i;
}
}
return sum;
}
}
public class ThreadNew {
public static void main(String[] args) {
//3.创建实现类的对象
NumThread numThread = new NumThread();
//4.将实现类的对象作为参数传递到TutureTask构造器中,创建FutureTak的对象
FutureTask futureTask = new FutureTask(numThread);
//5.将FutureTask的对象作为参数传递到Thread类的构造器中,创建Thread对象,并调用start()方法
new Thread(futureTask).start();
try {
Object sum = futureTask.get();
System.out.println("sum = " + sum);
} catch (InterruptedException | ExecutionException e) {
e.printStackTrace();
}
}
}
- 增加泛型
package CallableTest;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
//1.创建Callable的实现类
class NumThread implements Callable<Integer> {
//2.重写call方法
@Override
public Integer call() throws Exception {
int sum = 0;
for (int i = 0; i <= 100; i++) {
if (i % 2 == 0) {
System.out.println("i = " + i);
sum += i;
}
}
return sum;//进行了自动装箱 int→Integer
}
}
public class ThreadNew {
public static void main(String[] args) {
//3.创建实现类的对象
NumThread numThread = new NumThread();
//4.将实现类的对象作为参数传递到TutureTask构造器中,创建FutureTak的对象
FutureTask<Integer> futureTask = new FutureTask<Integer>(numThread);
//5.将FutureTask的对象作为参数传递到Thread类的构造器中,创建Thread对象,并调用start()方法
new Thread(futureTask).start();
try {
Integer sum = futureTask.get();
System.out.println("sum = " + sum);
} catch (InterruptedException | ExecutionException e) {
e.printStackTrace();
}
}
}
新增方式二:使用线程池(方式四)
- 线程池
- 使用线程池创建的好处
线程池API
package com.zzb;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
class Polls implements Runnable {
@Override
public void run() {
for (int i = 0; i <= 100; i++) {
if (i % 2 == 0) {
System.out.println(Thread.currentThread().getName() + "i = " + i);
}
}
}
}
public class ThreadsPool {
public static void main(String[] args) {
//1.提供指定线程数量的线程池
ExecutorService service = Executors.newFixedThreadPool(10);
//执行指定的线程的操作,需要提供实现Runnable接口或Callable接口实现类的对象
service.execute(new Polls());//适用于Runnable
//service.submit(new Polls1());//适用于Callable
service.shutdown();//关闭连接池
}
}
八.面试题
sleep()和wait()的区别
- 相同点:执行方法后,都可以使得当前的线程进入阻塞状态.
- 不同点:
- 两个方法声明的位置不同:Thread类中声明sleep(),Object类中声明wait()
- 调用的要求不同:sleep()可以在任何需要的场景下调用.而wait()必须使用在同步代码块和同步方法内.
- 关于是否释放锁的问题:
如果两个方法都使用在同步代码块或同步方法中,sleep()不会释放锁,wait()会释放锁.
创建多线程有几种方式?
- 四种,继承Thread类,实现Runnable接口,实现Callable接口,使用线程池创建.
谈谈你对同步代码块中 同步监视器 和 共享数据 的理解以及各自要求.
- 同步监视器:俗称锁.
- 任何一个类的对象都可以充当锁.
- 多个线程共用同一把锁.
- 共享数据: 多个线程共同操作的数据,即为共享数据.
需要使用同步机制将操作共享数据的代码包起来啊.不能包多了,也不能包少了.
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
