陕西城乡住房建设部网站,wordpress 密码注册,android app for wordpress,做网站什么笔记本好用Java基础学习多线程 一、多线程1.1 什么是多线程1.2 多线程的两个概念1.2.1 并发 1.3 多线程的实现方式1.4 多线程的成员方法1.5 线程的生命周期 二、线程安全1.6 同步方法1.7 锁lock1.8 死锁1.8 生产者和消费者 (等待唤醒机制)1.9 等待唤醒机制(阻塞队列方式实现#xff09;1… Java基础学习多线程 一、多线程1.1 什么是多线程1.2 多线程的两个概念1.2.1 并发 1.3 多线程的实现方式1.4 多线程的成员方法1.5 线程的生命周期 二、线程安全1.6 同步方法1.7 锁lock1.8 死锁1.8 生产者和消费者 (等待唤醒机制)1.9 等待唤醒机制(阻塞队列方式实现1.10 线程状态 二、线程池2.1 线程池的概述2.2 自定义线程池2.3 线程池到底多大才合适 一、多线程
1.1 什么是多线程
线程 线程是操作系统能够进行运算调度的最小单位。它被包含在进程之中是进程中的实际运作单位. 应用软件中互相独立可以同时运行的功能 进程: 进程是程序的基本执行实体
多线程的应用场景 软件中的耗时操作拷贝、迁移大文件加载大量的资源文件所有的聊天软件所有的后台服务器 …… 同时这些多项任务提升运行效率 1.2 多线程的两个概念
1.2.1 并发
并发:在同一时刻有多个指令在单个CPU上交替执行 并行:在同一时刻有多个指令在多个CPU上同时执行
1.3 多线程的实现方式
继承Thread类的方式进行实现
多线程的第一种启动方式: 自己定义一个类继承Thread重写run方法创建子类的对象并启动线程 重写的Run方法
package MyThreads;
//重写run方法Thread
public class MyThread extends Thread{Overridepublic void run() {for (int i 0; i 100; i) {System.out.println(getName() HelloWorld!!);}}
}
启动的线程
package MyThreads;
//新建Thread
public class Dom1 {public static void main(String[] args) {//创建线程对象MyThread t1 new MyThread();MyThread t2 new MyThread();//给线程添加名字t1.setName(线程1);t2.setName(线程2);//启动两个线程t1.start();t2.start();}
}
实现Runnable接口的方式进行实现
多线程的第二种启动方式: 自己定义一个类实现Runnable接口重写里面的run方法创建自己的类的对象创建一个Thread类的对象并开启线程 执行代码
package MyThreads;
//创建线程二
//利用runnable接口进行创建
/*
* 多线程的第二种启动方式:
* 1.自己定义一个类实现Runnable接口
* 2.重写里面的run方法
3.创建自己的类的对象
4.创建一个Thread类的对象并开启线程
*
* */public class Dom2 {public static void main(String[] args) {//创建线程需要执行的任务MyThread2 mr new MyThread2();//创建线程执行mr任务Thread t1 new Thread(mr);Thread t2 new Thread(mr);//给线程添加名字t1.setName(线程一);t2.setName(线程二);//开启线程t1.start();t2.start();}
}
接口代码
package MyThreads;
//创建线程二
//利用runnable接口进行创建
/*
* 多线程的第二种启动方式:
* 1.自己定义一个类实现Runnable接口
* 2.重写里面的run方法
3.创建自己的类的对象
4.创建一个Thread类的对象并开启线程
*
* */public class Dom2 {public static void main(String[] args) {//创建线程需要执行的任务MyThread2 mr new MyThread2();//创建线程执行mr任务Thread t1 new Thread(mr);Thread t2 new Thread(mr);//给线程添加名字t1.setName(线程一);t2.setName(线程二);//开启线程t1.start();t2.start();}
}
利用Callable接口和Future接口方式实现
多线程的第三种实现方式: 特点:可以获取到多线程运行的结果 创建一个类MyCallable实现Callable接口重写call (是有返回值的表示多线程运行的结果 )创建MyCallable的对象 (表示多线程要执行的任务)创建FutureTask的对象 (作用管理多线程运行的结果)创建Thread类的对象并启动 (表示线程) 对象
package MyThreads;import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
import java.util.concurrent.FutureTask;//线程创建3
/*
* 多线程的第三种实现方式:
特点:可以获取到多线程运行的结果
1。创建一个类MyCallable实现Callable接口
* 2。重写ca11 (是有返回值的表示多线程运行的结果 )
3。 创建MyCallable的对象 (表示多线程要执行的任务)
* 4。创建FutureTask的对象 (作用管理多线程运行的结果)
* 5。创建Thread类的对象并启动 (表示线程)
* */
public class Dom3 {public static void main(String[] args) throws ExecutionException, InterruptedException {//创建MyCallable的对象 (表示多线程要执行的任务)MyCallable mr new MyCallable();//创建FutureTask的对象 (作用管理多线程运行的结果)FutureTaskInteger ft new FutureTask(mr);//创建Thread类的对象并启动 (表示线程)Thread t1 new Thread(ft);//启动线程t1.start();//获取返回值Integer result ft.get();System.out.println(result);}
}
接口
package MyThreads;import java.util.concurrent.Callable;public class MyCallable implements CallableInteger {Overridepublic Integer call() throws Exception {int sum 0;for (int i 0; i 100; i) {sum sum i;}return sum;}
}
总结 按照不同的需求去完成我们的线程创建
1.4 多线程的成员方法
方法名称说明String getName()返回此线程的名称void setName(string name)设置线程的名字(构造方法也可以设置名字)static Thread currentThread()获取当前线程的对象static void sleep(long time)让线程休眠指定的时间单位为毫秒setPriority(int newPriority)设置线程的优先级final int getPriority()获取线程的优先级final void setDaemon(boolean on)设置为守护线程public static void yield()出让线程/礼让线程public static void join()插入线程/插队线程
细节前面四个成员方法 细节1 如果我们没有设置名字JVM会自动给我们设置Thread-x的名字x从0开始。 如果我们要设置名字。可以通过set设置也可以用继承的Thread的对象重写Thread的构造方法利用有参构造细节2 当启动JVM时就会创建多个线程我们以前所写的代码都在main线程里面进行的 细节3 sleep:哪条线程执行到该代码就会在这条线程上停留 测试代码
package MyThreadThod;
//成员方法演示
/*
* 1. 设置名字返回名字
* 2. 获取当前的线程名字
* 3. 让线程睡眠单位毫秒
* */
public class Dom1 {public static void main(String[] args) {//创建线程对象MyThread t1 new MyThread(lisi);MyThread t2 new MyThread(zhangsan);//开启线程t1.start();t2.start();}
}
继承Thread代码
package MyThreadThod;public class MyThread extends Thread{public MyThread() {}public MyThread(String name) {super(name);}Overridepublic void run() {for (int i 0; i 100; i) {//睡眠try {Thread.sleep(1000);} catch (InterruptedException e) {throw new RuntimeException(e);}System.out.println(getName()i);}}
}
成员方法优先级 范围 1~10 优先级越高就代表的执行他的概率就越高但是不是代表优先级越高就先执行该代码执行的顺序是随机的但是优先级越大随机的概率就越大 默认的优先级 5 package MyThreadThod;
//成员方法优先级
public class Dom2 {public static void main(String[] args) {//创建多线程执行的任务MyRunnable mr new MyRunnable();//创建Thread对象执行任务Thread t1 new Thread(mr);//设置优先级t1.setPriority(10);//启动t1.start();}
}
守护线程 这是表示“备胎守护线”当所守护的对象不存在的时候就没有存在的必要了就会提前结束线程 package MyThreadThod;
//成员方法守护线程
public class Dom3 {public static void main(String[] args) {//创建Thread对象MyThread t1 new MyThread();MyThread2 t2 new MyThread2();//将第二个设置为守护线程t2.setDaemon(true);t1.setName(女神);t2.setName(二货);t2.start();t1.start();}
}
出让线程 让执行的线程相对平均 Thread.yieId(); 插入线程 让该线程执行完后再执行该代码 package MyThreadThod;import MyThreads.MyThread1;//插入代码
public class Dom4 {public static void main(String[] args) throws InterruptedException {Thread t1 new MyThread1();t1.setName(洋芋);t1.start();t1.join();for (int i 0; i 10; i) {System.out.println(main线程 i);}}
}
1.5 线程的生命周期 二、线程安全 买票引发的安全问题 相同的票出现了多次出现了超出范围的票 解决方法
利用锁 特点1: 锁默认打开有一个线程进去了锁自动关闭 特点2:里面的代码全部执行完毕线程出来锁自动打开
代码实现
package MySafeThread.safe1;public class MySafe extends Thread{static int ticket 0;//锁对象必须是唯一的static Object obj new Object();Overridepublic void run() {//创建锁//作用如果有一个进入到了线程当中就会就不会让其他的线程进入直到//当该线程完成过后重写再抢夺CPUwhile (true){ //创建锁synchronized (obj){if (ticket100){//每个10毫秒在进行买票try {Thread.sleep(100);} catch (InterruptedException e) {throw new RuntimeException(e);}ticket;System.out.println(getName() 正在卖ticket张票了);}else {break;}}}}
}
锁对象必须得是唯一的 锁不唯一就表示打开这扇门的钥匙有多个不能让该代码执行完后才能让其他的线程抢夺这样会导致多执行重复的效果 一般情况下用当前代码的字节码文件.class来表示唯一对象
1.6 同步方法
就是把synchronized关键字加到方法上
格式 修饰符 synchronized 返回值类型 方法名(方法参数) {...}
特点1: 同步方法是锁住方法里面所有的代码 特点2:锁对象不能自己指定
里面在不同状态下调用的对象也不一样 非静态: this 静态:当前类的字节码文件对象 Stirngbuilder 与 Stringbuffer 的区别 Stringbuffer在多线程下相对于Stirngbuilder较为安全所以在单线程的情况下一般采用 Stringbuilder 主要修改的代码
package MySafeThread.safe2;import java.util.Timer;public class MyRunnable2 implements Runnable{int ticket 0;Overridepublic void run() {//1. 循环//2. 同步方法//3.判断是否完成未完成执行下列代码//4.判断是否完成已完成执行下列代码while (true){if (method()) break;}}//创建同步方法这里是非静态的调用时为thisprivate synchronized boolean method() {if (ticket 100) {return true;} else {try {Thread.sleep(10);} catch (InterruptedException e) {throw new RuntimeException(e);}ticket;System.out.println(Thread.currentThread().getName() 正在卖第 ticket 票了);}return false;}
}
1.7 锁lock
定义 虽然我们可以理解同步代码块和同步方法的锁对象问题但是我们并没有直接看到在哪里加上了锁在哪里释放了锁为了更清晰的表达如何加锁和释放锁JDK5以后提供了一个新的锁对象Lock Lock中提供了获得锁和释放锁的方法
void lock(): 获得锁void unlock(): 释放锁
手动上锁、手动释放锁
Lock是接口不能直接实例化 这里采用它的实现染ReentrantLock来实例化 ReentrantLock的构造方法 ReentrantLock():创建一个ReentrantLock的实例
1.8 死锁
两个锁互相嵌套导致两个锁都在等待着对方放下锁但是他们释放锁的情况是执行该所下面的代码才能释放这样就导致程序卡死出不去。
死锁实列
在这里插入代码片所以我们要在写代码的时候千万不要进行锁的嵌套写法一不小心就会掉进坑里面 package MySafeThread.BugLock;public class BUGLock extends Thread {static Object obj1 new Object();static Object obj2 new Object();Overridepublic void run() {if (A.equals(getName())){synchronized (obj1){System.out.println(拿到了线程A准备拿线程B);synchronized (obj2){System.out.println(拿到了线程B结束);}}} else if (B.equals(getName())) {if (B.equals(getName())){synchronized (obj2){System.out.println(拿到了线程B现在拿线程A);synchronized (obj1){System.out.println(拿到了线程A现在拿线程B);}}}}}
}
1.8 生产者和消费者 (等待唤醒机制)
生产者消费者模式是一个十分经典的多线程协作的模式
形象化理解 方法名称说明void wait(当前线程等待直到被其他线程唤醒void notify()随机唤醒单个线程void notifyAll()唤醒所有线程
启动窗口
package MyLock.WaitAndNotify;import java.io.FileOutputStream;public class waitNotiyDom {public static void main(String[] args) {//创建厨师和吃货的对象Cook cook new Cook();FoodAddict addict new FoodAddict();//设置名字cook.setName(厨师);addict.setName(吃货);cook.start();addict.start();}
}
厨师窗口
package MyLock.WaitAndNotify;public class Cook extends Thread{Overridepublic void run() {//循环while (true){//创建同步代码块synchronized (Desk.lock){//判断没有执行到尾部if (Desk.MaxFood 0){break;}else {//执行到末尾//首先判断状态值是否为0,是否有面条if (Desk.Food 1){//是1就执行等待try {Desk.lock.wait();} catch (InterruptedException e) {throw new RuntimeException(e);}}else {//是0就做食物释放所有等待代码System.out.println(厨师正在做食物);System.out.println(厨师已做完请吃);//将状态码变为1Desk.Food 1;//释放所以等待代码Desk.lock.notifyAll();}}}}}
}
吃货窗口
package MyLock.WaitAndNotify;public class FoodAddict extends Thread{Overridepublic void run() {while (true){synchronized (Desk.lock){//判断是否还能吃下去if (Desk.MaxFood 0){//不能吃下去了System.out.println(吃货吃不下了要g了);break;}else{//还能继续吃//判断桌子上面是否有吃的if (Desk.Food 0){//没有吃的就执行等待try {Desk.lock.wait();} catch (InterruptedException e) {throw new RuntimeException(e);}}else {//有吃的//将吃的碗数减1Desk.MaxFood--;System.out.println(吃货正在吃面条还可以吃Desk.MaxFood碗);//已经吃完释放所有的代码叫厨师吃饭了Desk.lock.notifyAll();//食物清空Desk.Food 0;}}}}}
}
桌子窗口
package MyLock.WaitAndNotify;
//表示桌子来放置面条的状态达到谁去执行的效果
public class Desk{//创建面的状态 0没有面条 1有面条public static int Food 0;//创建吃货吃的最多碗public static int MaxFood 10;//创建锁public static Object lock new Object();}
1.9 等待唤醒机制(阻塞队列方式实现 实现类 ArrayBlockingQueue 底层是数组有界限 LinkedBlockingQueue底层是链表无界但不是真正的无界最大为int的最大值。
厨师类
package MyLock.ArrayBlockingQueues;import java.util.concurrent.ArrayBlockingQueue;public class queueCooker extends Thread{ArrayBlockingQueueString queue;public queueCooker(ArrayBlockingQueueString queue) {this.queue queue;}Overridepublic void run() {while (true){//不需要再写锁了因为put当中写了try {queue.put(面条);System.out.println(厨师做了面);} catch (InterruptedException e) {throw new RuntimeException(e);}}}
}
吃货类
package MyLock.ArrayBlockingQueues;import java.util.concurrent.ArrayBlockingQueue;public class queueAddict extends Thread{ArrayBlockingQueueString queue;public queueAddict(ArrayBlockingQueueString queue) {this.queue queue;}Overridepublic void run() {while (true){try {String food queue.take();System.out.println(吃货在吃food);} catch (InterruptedException e) {throw new RuntimeException(e);}}}
}
执行类
package MyLock.ArrayBlockingQueues;import java.util.Arrays;
import java.util.concurrent.ArrayBlockingQueue;//阻塞队列方式实现等待唤醒任务
public class ArrayBlockingQueueDom {public static void main(String[] args) {//创建阻塞队列方式唯一ArrayBlockingQueueString queue new ArrayBlockingQueue(1);//创建两个变量赋名字并且把阻塞队列传入queueAddict addict new queueAddict(queue);queueCooker cooker new queueCooker(queue);addict.setName(吃货);cooker.setName(厨师);//开启线程addict.start();cooker.start();}
}
1.10 线程状态
六种红色的状态 新建状态(NEW ) -- 创建线程对象
就绪状态(RUNNABLE ) -- start方法
阻塞状态( BLOCKED ) -- 无法获得锁对象
等待状态 (WAITING ) -- wait方法
计时等待 (TIMED WAITING ) -- sleep方法
结束状态(TERMINATED ) -- 全部代码运行完毕
二、线程池
2.1 线程池的概述
以前写多线程的弊端 用到线程的时候就创建用完之后线程消失 会造成资源的浪费
所以现在出现了线程池来存储线程
线程池的核心原理 创建一个池子池子中是空的提交任务时池子会创建新的线程对象任务执行完毕线程归还给池子下回再次提交任务时不需要创建新的线程直接复用已有的线程即可但是如果提交任务时池子中没有空闲线程也无法创建新的线程任务就会排队等待 创建线程池的方法 Executors线程池的工具类通过调用方法返回不同类型的线程池对象
方法名称说明public static ExecutorService newCachedThreadPool()创建一个没有上限的线程池public static ExecutorService newFixedThreadPool(int nThreads)创建有上限的线程池
package MythreadPool.dom1;import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;//创建线程池初识线程池
public class Dom1 {public static void main(String[] args) {//创建无上限的线程池ExecutorService pool1 Executors.newCachedThreadPool();//创建有上限的线程池3个
// ExecutorService pool2 Executors.newFixedThreadPool(3);//提交任务pool1.submit(new MyRunnable1());pool1.submit(new MyRunnable1());pool1.submit(new MyRunnable1());pool1.submit(new MyRunnable1());}
}package MythreadPool.dom1;public class MyRunnable1 implements Runnable{Overridepublic void run() {for (int i 1; i 100; i) {System.out.println(Thread.currentThread().getName() ----------- i);}}
}
2.2 自定义线程池
任务拒绝策略说明ThreadPoolExecutor.AbortPolicy 默认策略: 丢弃任务并抛出RejectedExecutionException异常ThreadPoolExecutor.DiscardPolicy丢弃任务但是不抛出异常 这是不推荐的做法ThreadPoolExecutor.DiscardoldestPolicy抛弃队列中等待最久的任务 然后把当前任务加入队列中ThreadPoolExecutor.CallerRunsPolicy调用任务的run()方法绕过线程池直接执行
理解 自定义线程池
核心元素一: 正式员工数量 -------------- 核心线程数量(不能小于0)
核心元素二: 餐厅最大员工数 --------------- 线程池中最大线程的数量(最大数量 核心线程数量)
核心元素三: 临时员工空闲多长时间被辞退(值) -------- 空闲时间 (值) (不能小于0)
核心元素四: 临时员工空闲多长时间被辞退(单位) ------- 空闲时间(单位) (用TimeUnit指定)
核心元素五: 排队的客户 -------- 阻塞队列 (不能为null)
核心元素六: 从哪里招人 --------- 创建线程的方式(不能为null)
核心元素七: 当排队人数过多超出顾客请下次再来(拒绝服务) ------ 要执行的任务过多时的解决方案(不能为null)
package MythreadPool.dom2;import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;//自定义线程池
public class dom2 {public static void main(String[] args) {ThreadPoolExecutor pool new ThreadPoolExecutor(3 , //核心线程数量表示的正式员工6, //最大线程数量总员工数量60,//空闲线程最大的存活时间TimeUnit.SECONDS, //表示当前最大存活的时间单位new ArrayBlockingQueue(3),//排队的客户Executors.defaultThreadFactory(),//创建线程工厂new ThreadPoolExecutor.AbortPolicy()//拒绝方法);}
}
总结 创建一个空的池子有任务提交时线程池会创建线程去执行任务执行完毕归还线程 不断的提交任务会有以下三个临界点: 当核心线程满时再提交任务就会排队当核心线程满队伍满时会创建临时线程当核心线程满队伍满临时线程满时会触发任务拒绝策略 2.3 线程池到底多大才合适
CPU 密集型运算 -------- 最大并行数 I
l/0 密集型运算 ---------- 最大并行数 * ”期望 CPU利用率 * 总时间(CPU计算时间等待时间) / CPU计算时间
例如 4核8线程
