多线程
process(进程)与Thread(线程)
- 说起进程,就不得不说程序。程序是指令和数据的有序集合,其本身没有任何运行的含义,是一个静态的概念
- 进程是执行程序的过程,是一个动态的概念。是系统资源分配单位
- 通常一个进程中可以有多个线程,当然一个进程至少一个线程,不然没有存在的意义。线程是CPU调度和执行的单位
注意:
很多多线程是模拟出来的,真正的多线程是指cpu即多核,如服务器。如果模拟出来的多线程,即在一个cpu的情况下,在同一个时间点,cpu只能执行一个代码,因为切换的很快,所以就有同时执行的错觉;
线程
-
线程分用户线程和守护线程;虚拟机必须确保用户线程执行完毕,不用等待守护线程执行完毕
-
线程就是独立的执行路径;
-
在程序运行时,即使没有自己创建线程,后台也会有多个线程,如主线程, gc(垃圾回收)线程;
-
main()称之为主线程,为系统的入口,用于执行整个程序;
-
在一个进程中,如果开辟了多个线程,线程的运行由调度器(CPU)安排调度,调度器是与操作系统紧密相关的,先后顺序是不能人为的干预的。
-
对同一份资源操作时,会存在资源抢夺的问题,需要加入并发控制;
-
线程会带来额外的开销,如cpu调度时间,并发控制开销。
-
每个线程在自己的工作内存交互,内存控制不当会造成数据不一致
-
死亡后的线程不可以再次被启用
线程的创建
三种方式
继承Thread类
-
自定义线程类继承Thread类;
-
重写run方法,编写程序执行体;
-
创建线程对象,调用**start()**方法启动线程;
-
线程开启不一定立即执行,有CPU调度安排;
不建议使用:避免OOP单继承局限性!
package com.zhou.thread;
public class runThreadDome01 extends Thread{
@Override//重写 run方法
public void run() {
// run方法体
for (int i = 0; i < 20; i++) {
System.out.println("我想你了:");
}
}
public static void main(String[] args) {
// 创建线程类对象
runThreadDome01 run01 = new runThreadDome01();
// 调用start方法开启线程
run01.start();
for (int i = 0; i < 20; i++) {
System.out.print("你想我没!");
}
}
}
案例
package com.zhou.thread;
import org.apache.commons.io.FileUtils;
import java.io.File;
import java.io.IOException;
import java.net.URL;
//练习Thread,实现多线程同步下载图片
public class runThreadDome02 extends Thread{
//成员属性,downloader所需参数
private String url;
private String name;
//构造方法,创建对象时初始化成员变量
public runThreadDome02(String url,String name){
this.url = url;
this.name = name;
}
@Override
public void run() {
WebDownloader webDownloader = new WebDownloader();
webDownloader.downloader(url,name);
System.out.println("下载的文件名为" + name);
}
public static void main(String[] args) {
runThreadDome02 run01 = new runThreadDome02("https://pineapple.edgeless.top/picbed/home/f1.jpg","Thread1.jpg");
runThreadDome02 run02 = new runThreadDome02("https://pineapple.edgeless.top/picbed/home/f2.jpg","Thread2.jpg");
runThreadDome02 run03 = new runThreadDome02("https://pineapple.edgeless.top/picbed/home/f3.jpg","Thread3.jpg");
run01.start();
run02.start();
run03.start();
}
}
//下载器
class WebDownloader{
// 下载方法
public void downloader(String url,String name){
try {
FileUtils.copyURLToFile(new URL(url),new File(name));
} catch (IOException e) {
System.out.println("IO异常,dounloader方法出现问题");
}
}
}
实现Runnable接口
-
定义一个类实现Runnable接口;
-
实现run()方法,编写线程执行体;
-
创建线程对象,调用**start()**方法启动线程;
建议使用:避免了单继承的局限性,灵活方便,方便同一个对象被多个线程的使用!
package com.zhou.thread;
//创建线程二,实现Runnable接口
public class ThreadRunnableDome02 implements Runnable{
@Override
public void run() {
for (int i = 0; i < 20; i++) {
System.out.println("明慧是傻子!");
}
}
public static void main(String[] args) {
ThreadRunnableDome02 Runnable01 = new ThreadRunnableDome02();
// 创建线程对象,通过线程对象来开启我们的线程,代理
// 通过Thread构造方法传一个Runnable实现类对象
// 创建一个关于Runnable实现类有关的线程,
// 通过start开启线程;
Thread thread = new Thread(Runnable01);
thread.start();
// 代码简化使用匿名对象:
// new Thread(Runnable01).start();
for (int i = 0; i < 20; i++) {
System.out.print("明慧不是傻子!");
}
}
}
实现Callable接口
- 实现Callable接口,有返回值;
- 重写**call()**方法,需要抛出异常;
- 创建目标线程;
- 创建执行服务:ExecutorService ser = Executors.newFixedThreadPool(1);
- 提交执行服务:Future result1 = ser.submit(t1);
- 获取结果:boolean r1 result1.get()
- 关闭服务:ser.shutdownNow()
多个线程操做一个对象
package com.zhou.thread;
//多个线程同时操作一个对象
//买火车票案例
public class ThreadDome01 implements Runnable{
// 票数
private int ticketNums = 10;
@Override
public void run() {
while (true){
// ticket:票的意思;
if (ticketNums<=0){
break;
}
// sleep()线程休眠参数是毫秒;
try {
Thread.sleep(200);
} catch (InterruptedException e) {
e.printStackTrace();
}
// currentThread()(获取当前线程).getName()(获取线程名)
System.out.println(Thread.currentThread().getName() + "拿到了第" + ticketNums-- + "票");
}
}
public static void main(String[] args) {
ThreadDome01 threadDome01 = new ThreadDome01();
new Thread(threadDome01,"黄牛1").start();
new Thread(threadDome01,"黄牛2").start();
new Thread(threadDome01,"黄牛3").start();
}
}
//运行结果
// 黄牛3拿到了第10票
// 黄牛2拿到了第10票
// 黄牛1拿到了第10票
// 黄牛2拿到了第9票
// 黄牛3拿到了第8票
// 黄牛1拿到了第7票
// 黄牛2拿到了第6票
// 黄牛3拿到了第5票
// 黄牛1拿到了第4票
// 黄牛3拿到了第3票
// 黄牛2拿到了第3票
// 黄牛1拿到了第2票
// 黄牛2拿到了第1票
// 黄牛3拿到了第1票
// 黄牛1拿到了第0票
发现:有多个线程操作一个数据:出现线程安全问题
解决办法:
静态代理:
实现接口
Lambda表达式
- 希腊字母表中排序第十一位的字母,英文名为Lambda
- 避免匿名内部类定义过多;
- 让代码看起来简洁;
- 属于函数式编程;
- 去掉一堆没有意义的代码,只留下了核心逻辑;
Lambda表达式重要特征:
- **可选类型声明:**不需要声明参数类型,编译器可以统一识别参数值。
- **使用Lambda表达式前提:**是一个函数式接口;
- **可选的参数圆括号:**一个参数无需定义圆括号,但多个参数需要定义圆括号。
- **可选的大括号:**如果主体包含了一个语句,就不需要使用大括号。
- **可选的返回关键字:**如果主体只有一个表达式返回值则编译器会自动返回值,大括号需要指定明表达式返回了一个数值。
函数式接口
Functional Interface(函数式接口)
定义:只包含唯一一个抽象方法的接口
对于函数式接口我们可以通过lambda表达式来创建该接口的对象;
Lambda案例
package com.zhou.thread;
public class LambdaDome01 {
//(第一次简化)外部的类拿过来改成静态内部类
/*
static class Love implements zhou{
@Override
public void love(String a, String b) {
System.out.println(a+ "Love"+ b);
}
}
*/
public static void main(String[] args) {
// (第二次简化) 把静态内部类改成局部内部类
/*
class Love implements zhou{
@Override
public void love(String a, String b) {
System.out.println(a+ "Love"+ b);
}
}
*/
// 第三次把原来代码注释掉
/* zhou love = new Love();
love.love("周林","孙明慧");
}*/
// 第三次简化,把原来代码注释掉改成匿名内部类
/*
zhou love = new zhou()*/
/* new Love(); 把原来的 new 类名 改为new 接口实现类*//*
{
@Override
public void love(String a, String b) {
System.out.println(a+ "Love"+ b);
}
};
love.love("周林","孙明慧");
*/
// 转换成Lamdba表达式
/* zhou love = (String a,String b)->{
System.out.println(a+ "Love"+ b);
};*/
// Lambda表的是简化,省去掉可参数类型,当参数为一个时可以省略参数外的外的括号
//
zhou love = ( a, b)-> System.out.println(a+ "Love"+ b);
love.love("周林","孙明慧");
}
}
interface zhou{
void love(String a,String b);
}
//第一次简化把外部的类放到内部
/*
class Love implements zhou{
@Override
public void love(String a, String b) {
System.out.println(a+ "Love"+ b);
}
}
*/
线程的五大状态:
public static enum Thread.State
extends Enum<Thread.State>线程状态。 线程可以处于以下状态之一:
NEW
尚未启动的线程处于此状态。
RUNNABLE
在Java虚拟机中执行的线程处于此状态。
BLOCKED//阻塞
被阻塞等待监视器锁定的线程处于此状态。
WAITING//等待
正在等待另一个线程执行特定动作的线程处于此状态。
TIMED_WAITING//waiting 等待
正在等待另一个线程执行动作达到指定等待时间的线程处于此状态。
TERMINATED//结束
已退出的线程处于此状态。
一个线程可以在给定时间点处于一个状态。 这些状态是不反映任何操作系统线程状态的虚拟机状态。
状态观测
public class threadStat {
public static void main(String[] args) {
Thread thread = new Thread(()->{
for (int i = 0; i < 5; i++) {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println("周林");
});
// 观察状态
// 调用get.state();来查看状态
Thread.State state = thread.getState();
System.out.println("状态是" + state);
thread.start();//启动线程;
state = thread.getState();//更新线程状态
System.out.println("状态是" + state);
while (state!= Thread.State.TERMINATED){//只要线程不终止,就一直输出状态;
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
state = thread.getState();//更新状态;
System.out.println("状态是" + state);//输出状态
}
}
}
线程的方法:
setPriority(int newPriority) 更改线程权限
线程的停止:
//测试停止线程-
// 建议线程正常停止-->利用次数,不建议使用死循环。
// 建议使用标志位----->设置标志位。
// 不建议使用stop或者destroy等过时或者JDK不建议使用的方法
public class threadStop implements Runnable{
// 设置标志位
private boolean flag = true;
@Override
public void run() {
int i = 0;
while(flag){
System.out.println("线程正在运行" + i++);
}
}
// 设置一个公共的方法来停止线程
public void stop(){
this.flag = false;
}
public static void main(String[] args) {
threadStop threadStop = new threadStop();
new Thread(threadStop).start();
for (int i = 0; i < 200; i++) {
System.out.println("main"+i);
if(i==179){
// 切换标志位让线程停止
threadStop.stop();
System.out.println("线程停止");
}
}
}
}
线程的休眠:
- sleep(时间)指当前线程阻塞的毫秒数(1000毫秒等于1秒);
- sleep存在异常InterredException;
- sleep时间到达后线程进入就绪状态;
- sleep可以模拟网路延时,倒计时等;
- 每个对象都有一个锁,sleep不会释放锁;
**模拟延时:**可以放大问题的发生性;
线程暂停(礼让yield)
- 让当前执行的线程暂停但不阻塞;
- 将线程从运行状态转换为就绪状态;
- 让CPU重新调度,礼让不一定成功看CPU重新分配情况;
package com.zhou.thread;
//测试礼让,礼让不一定成功;
public class threadYield {
public static void main(String[] args) {
yiled yiled = new yiled();
//Thread构造方法(线程类对象,"起的名字")
new Thread(yiled,"a").start();
new Thread(yiled,"b").start();
}
}
class yiled implements Runnable{
@Override
public void run() {
System.out.println(Thread.currentThread().getName()+"线程开始执行");
//调用礼让方法
Thread.yield();
System.out.println(Thread.currentThread().getName()+"线程结束执行");
}
}
现成的强制执行:(Join)
- Join合并线程,待此线程执行完之后,在执行其他线程,其他线程阻塞,可以想象成插队
- 方法:用线程对象调用**jion()**方法;
线程的优先级
- Java提供一个线程调度器来监控程序启动后进入就绪状态的所有线程,线程的调度器按照优先级决定应该调度哪个线程来执行;
- 线程的优先级用数字表示,范围是从1~10
- 先设置优先级,在开启线程;默认优先级是5
- 使用**getPriority().setPriority(int XXX)**来改变或者获取优先级;
//测试线程优先级
public class threadPriority {
public static void main(String[] args) {
// 打印主线程优先级
System.out.println(Thread.currentThread().getName()+"优先级是"+Thread.currentThread().getPriority());
Priority priority = new Priority();
Thread t1 = new Thread(priority);
Thread t2 = new Thread(priority);
Thread t3 = new Thread(priority);
Thread t4 = new Thread(priority);
Thread t5 = new Thread(priority);
Thread t6 = new Thread(priority);
// 先设置优先级
t1.start();//默认
t2.setPriority(1);
t2.start();
t3.setPriority(4);
t3.start();
t4.setPriority(5);
t4.start();
t5.setPriority(7);
t5.start();
t6.setPriority(9);
t6.start();
}
}
class Priority implements Runnable{
@Override
public void run() {
System.out.println(Thread.currentThread().getName()+"优先级是"+Thread.currentThread().getPriority());
}
}
保护线程
- 线程分用户线程和守护线程;
- 虚拟机必须确保用户线程执行完毕,不用等待守护线程执行完毕
- 通过**对象名.setDaemon(true)**将一个对象设置成保护线程;
- 一般线程setDaemon(x)里的参数X都是false代表用户线程的意思
- 保护线程并不一定执行完毕
public class threadDaemon {
public static void main(String[] args) {
God god = new God();
you you = new you();
Thread g1 = new Thread(god);
// 设置保护线程
g1.setDaemon(true);//默认是false表示用户线程
g1.start();
new Thread(you).start();
}
}
class God implements Runnable{
@Override
public void run() {
while (true){
System.out.println("你爱我!");
}
}
}
class you implements Runnable{
@Override
public void run() {
for (int i = 0; i < 36500; i++) {
System.out.println("我爱你第"+i+"天");
}
System.out.println("我爱你的下一世开始");
}
}
线程的同步
**并发:**同一个对象被多个线程操作
多个线程访问一个对象,并且某些线程还想修改这个对象,我们就需要线程的同步;
**线程同步:**其实是一种等待机制,多个需要同时访问此对象的线程进入对象的线程池形成排队等待,等待前面的使用完毕,下一个线程在使用;
-
由于同一进程的多个线程共享同一块存储空间,在带来方便的同时,也带来了访问冲突问题,为了保证数据在方法中被访问时的正确性,在访问时加入锁机制
synchronized ,当一个线程获得对象的排它锁,独占资源,其他线程必须等待,使用后释放锁即可但存在以下问题:
- 一个线程持有锁会导致其他所有需要此锁的线程挂起;
- 在多线程竞争下,加锁,释放锁会导致比较多的上下文切换和调度延时,引起性能问题;
- 如果一个优先级高的线程等待一个优先级低的线程释放锁 会导致优先级倒置,引起性能问题.
synchronized关键字
两种用法:
-
加了synchronized修饰符的方法叫同步方法;
synchronized方法控制“对象”的访问,每个对象对应一把锁每个synchronized方法都必须获得调用该方法的对象锁才能执行,否则线程会阻塞,方法一旦执行,就独占该锁,直到该方法返还才能释放锁,后面被阻塞的线程才能获得这个锁,继续执行
缺陷:若将一个大的方法申明为synchronized将会影响效率;
// Synchronized:同步的意思 public class Synchronized { public static void main(String[] args) { ticket ticket = new ticket(); new Thread(ticket,"黄牛1").start(); new Thread(ticket,"黄牛2").start(); new Thread(ticket,"黄牛3").start(); } } class ticket implements Runnable { private int ticketNums = 10; boolean flag = true;//设置标志位,外部停止方式; @Override public void run() { // 买票 while (flag) { mTicket(); try { Thread.sleep(1000);//方大问题的发生性 } catch (InterruptedException e) { e.printStackTrace(); } } } //没有加synchronizd时会出现结果-1的现象 // private void mTicket() { private synchronized void mTicket() { if (ticketNums <= 0) { flag = false; return; } System.out.println(Thread.currentThread().getName() + "票卖了一张,当前票数" + ticketNums--); } }
- 同步块:synchronized(Obj){ }其中Obj一般是一个增删改的变量;
- Obj可以是任何对象,但是推荐使用共享资源作为同步监视器
- 同步方法中无需指定同步监视器,因为同步方法的同步监视器就是this,就是这个对象本身,或者是class;
- 同步监视器的执行过程:
- 第一个线程访问,锁定同步监视器,执行其中代码;
- 第二个线程访问,发现同步监视器被锁定,无法访问;
- 第一个线程访问完毕,解锁同步监视器;
- 第二个线程访问,发现同步监视器没有锁,然后锁定访问;
死锁
多个线程互相抱着对方需要的资源,然后形成僵持;
产生死锁的四个必要条件:
- 互斥条件:一个资源每次只能被一个进程使用;
- 请求与保持条件:一个进程因请求资源而堵塞时,对以获得的资源保持不放;
- 不剥夺条件:进程以获得的资源,在未使用完之前,不能强行剥夺;
- 循环等待条件:若干进程之间形成一种头尾相接的循环等待资源关系;
死锁避免方法
只要破解四个必要条件之一就可;
Lock(锁)
- JDK5.0开始,Java提供了更大的线程同步机制——通过显示定义同步锁对象来实现同步。同步锁使用Lock对象来充当;
- java.util.concurrent.locks.Lock接口是控制多个线程对共享资源进行访问的工具。锁提供了对共享资源的独占访问,每次只能有一个线程对Lock对象加锁,线程开始访问共享资源之前应先获得Lock对象;
- ReentrantLock(可重入锁)类实现了Lock,它拥有与synchronized相同的并发性和内存语义,在实现线程安全的控制中,比较长用的是ReentrantLock,可以显示加锁、释放锁;
// 定义一个可重用锁
private final ReentrantLock lock = new ReentrantLock();
public void A(){
lock.lock();
try {
// 要保证安全的代码;
}finally {
lock.unlock();
// 如果同步代码有异常,要将unlock()写到finally语句块里;
}
}
synchronized与Lock对比
-
Lock是显示锁(要手动开启和关闭,)synchronized是隐式锁,除了作用域自动释放;
-
Lock只是代码块锁,synchronized有代码块锁和方法锁;
-
使用Lock锁 JVM将花费较少的时间来调度线程,性能好。并且更具有扩展性
-
优先顺序:
Lock > 同步代码块(已经进入了方法体,分配了相应的资源)> 同步方法(在方法体之外);
线程通信
Java中提供了几个方法解决线程通信问题
wait() //表示线程一直等待,直到其他线程通知,与sleep不同,会释放锁
wait(long timeout)//可以指定等待毫秒数
notify()//唤醒一个处于等待的线程
notifyAll()//唤醒同一个对象上多有调用wait()方法的线程,优先级别高的线程优先调度;
线程池
**好处:**1、提高响应速度;2、降低资源消耗;3、便于管理;
corePoolSize:核心池的大小;
maximumPoolSize:最大线程数;
keepAliveTime:线程没有任务时保持多长时间后终止;
使用线程池
-
JDK5.0起提供了线程池相关的API:ExecutorService和Executors
-
ExecutorService:真正的线程池接口。常见的子类ThreadPoolExecutor
- void execute(Runnable command):执行任务/命令,没有返回值,一般用来执行Runnable
- Futuresubmit(Callabletask):执行任务,有返回值,一般执行Callable
- void shutdown():关闭连接池
-
Executors:工具类,线程池的工厂类,用于创建并返回不同类型的线程池
创建固定线程池
// 创建线程池子,参数是固定池子的大小
ExecutorService service = Executors.newFixedThreadPool(10);
开启/关闭服务
service.execute(new MyThread());//参数是线程对象;
service.shutdown();