目录
线程与进程
-
进程
-
是指一个内存中运行的应用程序,每个进程都有一个独立的内存空间。
-
-
线程
-
是进程中的一个执行路径,共享一个内存空间,线程之间可以自由切换,并发执行. 一个进程最少有一个线程
-
线程实际上是在进程基础之上的进一步划分,一个进程启动之后,里面的若干执行路径又可以划分成若干个线程
-
线程和进程的关系:进程就像一款软件或应用程序,线程就是这个软件的一个或多个执行路径。
线程调度
-
分时调度
-
所有线程轮流使用 CPU 的使用权,平均分配每个线程占用 CPU 的时间。
-
-
抢占式调度
-
优先让优先级高的线程使用 CPU,如果线程的优先级相同,那么会随机选择一个(线程随机性,优先级更高的线程,随机概率更大),Java使用的为抢占式调度。
-
-
CPU使用抢占式调度模式在多个线程间进行着高速的切换。对于CPU的一个核心而言,某个时刻,只能执行一个线程,而 CPU的在多个线程间切换速度相对我们的感觉要快,看上去就是 在同一时刻运行。 其实,多线程程序并不能提高程序的运行速度,但能够提高程序运行效率(比如说一个需要用户输入的程序,如果用户不输入,程序就不会往下执行,但是如果有多线程,那么等待的时间可以执行其他程序。),让CPU的 使用率更高。
究竟是多线程执行程序好还是顺序执行程序好?当1000个程序员同时操作8核心的数据库时,这个问题应该怎么考虑?
答:应该是顺序执行好。因为切换程序需要时间,而1000个程序员同时操作数据库所需要切换程序的次数远不止1000次,浪费太多时间。而顺序执行程序只需要切换1000次。
同步(线程不安全)与异步(线程安全)
同步:排队执行 , 效率低但是安全.
异步:同时执行 , 效率高但是数据不安全.
并发与并行
并发:指两个或多个事件在同一个时间段内发生。(如一天内的并发量是多少)
并行:指两个或多个事件在同一时刻发生(同时发生)。
编写多线程程序
-
方式一:
-
要写一个继承Thread的类
-
将要执行的程序重写进run方法,但通过start方法来开启线程
-
Thread
Thread的使用
public static void main(String[] args) { MyThread m = new MyThread(); //主线程和m线程都是并行执行。抢占式调度,谁先抢到就执行谁 m.start();//开启新的线程 for (int i=0;i<10;i++){ System.out.println("汗滴禾下土"+i); } } public class MyThread extends Thread { /** * run方法就是线程要执行的任务方法 */ @Override public void run() { //这里的代码 就是一条新的执行路径。 //这个路径的触发方式,不是调用run方法,而是通过thread对象的start()来启动 for (int i=0;i<10;i++){ System.out.println("锄禾日当午"+i); } } }
程序执行逻辑
Runnable
public static void main(String[] args) { //实现Runnable //1.创建一个任务对象 MyRunnable r = new MyRunnable(); //2.创建一个线程,并为其分配一个任务 Thread t = new Thread(r); //3.执行这个线程 t.start(); for (int i=0;i<10;i++){ System.out.println("疑是地上霜"+i); } } /** * 用于给线程进行执行的任务 */ public class MyRunnable implements Runnable { @Override public void run() { //线程的任务 for (int i=0;i<10;i++){ System.out.println("床前明月光"+i); } } }
Runnable与Thread对比的优势
实现Runnable 与 继承Thread相比有如下优势:
-
1.通过创建任务,然后给线程分配的方式来实现的多线程,更适合多个线程同时执行相同任务的情况。
-
2.可以避免单继承所带来的局限性。
-
3.任务与线程本身是分离的,提高了程序的健壮性
-
4.后续学习的线程池技术,接受Runnable类型的任务,不接受Thread类型的线程。
Thread类常用方法
设置和获取线程名称
设置名称:new Thread(new MyRunnable(),名称)
获取名称:.currentThread().getName()
线程休眠:Thread.sleep(时间:单位毫秒);
Thread.currentThread().getName() new Thread(new MyRunnable(),"锄禾日当午").start();
public static void main(String[] args) { System.out.println(Thread.currentThread().getName()); new Thread(new MyRunnable(),"锄禾日当午").start(); new Thread(new MyRunnable()).start(); } static class MyRunnable implements Runnable{ @Override public void run() { System.out.println(Thread.currentThread().getName()); } }
线程阻塞
线程阻塞:线程中所有比较消耗时间的操作。如文件读取,接收用户输入,线程休眠等。
线程中断
-
一个线程是一个独立的执行路径,它是否应该结束,应该由其自身决定。
-
//给线程t1添加中断标记 t1.interrupt(); //在sleep的时候,程序会检查t1有没有中断标记,如果有,就进入catch块。
-
try { Thread.sleep(1000); } catch (InterruptedException e) { System.out.println("发现了中断标记,但是我们这个线程自杀"); return;//run方法是线程的任务,这方法完毕就表示任务执行完毕了,所以return就代表了线程结束。 //e.printStackTrace(); }
守护线程
-
线程:分为守护线程和用户线程
-
用户线程:当一个进程不包含任何的存活的用户线程时,进程结束
-
守护线程:守护用户线程的,当最后一个用户线程结束时,所有守护线程自动死亡。
-
能创建的线程都是用户线程
-
一定要在线程启动之前设置为守护线程
-
设置为守护线程的方法
线程名称.setDaemon(true);//设置为守护线程
线程安全问题
解决线程安全问题
1.同步代码块
格式:synchronized(锁对象){同步的代码内容}
创建锁对象:private Object o = new Object();//创建锁对象
注意:锁对象必须在run()方法前面定义的类属性变量,这样才是多个线程使用同一把锁,只有这样才能有效。如果在run()方法内部定义的锁对象,每个线程在执行run()任务时,都创建了不同的锁,不能实现多个线程排队执行的操作。
功能:多个线程排队执行,只有当一个锁对象的线程执行完,被释放后,下一个线程锁对象才会执行同步的代码内容。
-
先启动的线程抢到锁的几率比后启动的线程大。
-
谁先抢到的,那么其连续抢到的几率就比较高(因为自己释放锁,相比其他线程来说,自己距离锁最近。所以反手又抢到自己的锁,)
2.同步方法
格式:在方法前加synchronized修饰符
例:public synchronized boolean sale(){}
同步方法的锁:
-
如果不是static静态方法,那么锁对象就是this(即创建的任务对象),因此线程的任务对象必须是同一个,不能每个线程都new一个任务对象。这样就不是多个线程使用一个锁了。
-
如果是static静态方法,那么锁对象就是类名.class
-
当一段程序同时使用一个或多个同步代码块(和/或)同步方法,并且使用同一把锁this,那么只有一个同步代码块/同步方法执行完成,另外一个才能执行。
3.显式锁Lock
创建锁对象: ReentrantLock l = new ReentrantLock();
使用:
-
在程序开始前上锁。l.lock()
-
在程序结束后解锁。l.unlock()
隐式锁sync和显式锁lock的区别
在面试的过程中有可能会问到:在Java并发编程中,锁有两种实现:使用隐式锁和使用显示锁分别是什么?两者的区别是什么?所谓的显式锁和隐式锁的区别也就是说说Synchronized(下文简称:sync)和lock(下文就用ReentrantLock来代之lock)的区别。
本文主要内容:将通过七个方面详细介绍sync和lock的区别。通过生活case中的X二代和普通人比较大家更容易理解这两者之间的区别
Java中隐式锁:synchronized;显式锁:lock
一:出身不同
从sync和lock的出身(原始的构成)来看看两者的不同。
Sync:Java中的关键字,是由JVM来维护的。是JVM层面的锁。
Lock:是JDK5以后才出现的具体的类。使用lock是调用对应的API。是API层面的锁
sync是底层是通过monitorenter进行加锁(底层是通过monitor对象来完成的,其中的wait/notify等方法也是依赖于monitor对象的。只有在同步块或者是同步方法中才可以调用wait/notify等方法的。因为只有在同步块或者是同步方法中,JVM才会调用monitory对象的);通过monitorexit来退出锁的。
而lock是通过调用对应的API方法来获取锁和释放锁的。
我们通过Javap命令来查看调用sync和lock的汇编指令:
编辑
从编译后的汇编指令,我们也能够清晰的看出sync关键字和lock的区别。
第一不同一句话概述:可以把sync理解为官二代或者是星二代。从娘胎出来自带光环的。Lock就是我们普通努力上进的人。
二:使用方式不同
Sync是隐式锁。Lock是显示锁
所谓的显示和隐式就是在使用的时候,使用者要不要手动写代码去获取锁和释放锁的操作。
我们大家都知道,在使用sync关键字的时候,我们使用者根本不用写其他的代码,然后程序就能够获取锁和释放锁了。那是因为当sync代码块执行完成之后,系统会自动的让程序释放占用的锁。Sync是由系统维护的,如果非逻辑问题的话话,是不会出现死锁的。
在使用lock的时候,我们使用者需要手动的获取和释放锁。如果没有释放锁,就有可能导致出现死锁的现象。手动获取锁方法:lock.lock()。释放锁:unlock方法。需要配合tyr/finaly语句块来完成。
两者用法对比如下:
编辑
用生活中的一个case来形容这个不同:官二代和普通人的你在进入机关大院的时候待遇。官二代不需要出示什么证件就可以进入,但是你需要手动出示证件才可以进入。
三:等待是否可中断
Sync是不可中断的。除非抛出异常或者正常运行完成
Lock可以中断的。中断方式:
1:调用设置超时方法tryLock(long timeout ,timeUnit unit)
2:调用lockInterruptibly()放到代码块中,然后调用interrupt()方法可以中断
生活中小case来理解这一区别:官二代一般不会做饭。都会去餐厅点餐等待着餐厅出餐。普通人的你既可以去餐厅等待,如果等待时间长的话,你就可以回去自己做饭了。
四:加锁的时候是否可以公平
Sync;非公平锁
lock:两者都可以的。默认是非公平锁。在其构造方法的时候可以传入Boolean值。
true:公平锁
false:非公平锁
生活中小case来理解这个区别:官二代一般都不排队,喜欢插队的。普通人的你虽然也喜欢插队。但是如果遇到让排队的情况下,你还是会排队的。
Lock的公平锁和非公平锁:
五:锁绑定多个条件来condition
Sync:没有。要么随机唤醒一个线程;要么是唤醒所有等待的线程。
Lock:用来实现分组唤醒需要唤醒的线程,可以精确的唤醒,而不是像sync那样,不能精确唤醒线程。
六:从性能比较
生活小case理解:在我们一般的认知中,官二代一般都是比较坑爹的吧。但是这几年也有很多官二代或者是富二代改变了态度,端正自己态度,靠自己能力而不是拼爹了。
七:从使用锁的方式比较
公平锁与非公平锁
公平锁:解锁后,所有线程排队执行。
非公平锁:解锁后,所有线程抢占式执行,谁先抢到就执行谁。上面的三个锁都是非公平锁。
公平锁的实现:
//显式锁 l:fair参数为true 就表示公平锁 private ReentrantLock l = new ReentrantLock(true);
线程死锁
出现的原因:一个有锁的方法调用了另外一个有锁的方法。
解决方法:不要出现锁调锁的情况。
多线程通信问题
什么是多线程通信问题?
举例:现在有两个线程,一个是下载音乐的线程A,一个是播放音乐的线程B。线程A执行完后要告诉线程B开始执行,这就涉及两个线程的通信问题。
生产者与消费者
什么是生产者与消费者?
举例:厨师和服务员。厨师相当于生产者,服务员是消费者。只有当生产者生产东西出来后,消费者才能工作。
整个逻辑是:
前提:一个厨师+一个服务员+一个盘子
1.当厨师在煮菜时,服务员在休息(休眠)只有当煮完菜放到盘子上,服务员(被唤醒)去上菜。
2.当服务员上菜后,由于没有盘子装菜,那么厨师也休息(休眠),只有当服务员上完菜洗干净盘子后,厨师才被唤醒,继续步骤1的操作。
-
对于这种要求顺序操作的线程,不能用线程锁进行控制,因为我们所学的线程锁都是非公平锁,即是刚解锁的线程很容易反手又抢占回线程锁。
-
正确的方法应该是在一个线程(被唤醒)执行时,休眠另一个线程
格式:
{ 执行炒菜的程序 } this.notifyAll();//唤醒当前在this下睡着的所有线程 try { this.wait(); //唤醒以后,厨师厨师线程休眠 } catch (InterruptedException e) { e.printStackTrace(); }
public static void main(String[] args) { Food f = new Food(); new Cook(f).start(); new Waiter(f).start(); } //厨师 static class Cook extends Thread { private Food f; public Cook(Food f) { this.f = f; } @Override public void run() { for (int i = 0; i < 100; i++) { if (i % 2 == 0) { f.setNameAndSaste("老干妈小米粥", "香辣味"); } else { f.setNameAndSaste("煎饼果子", "甜辣味"); } } } } //服务生 static class Waiter extends Thread { private Food f; public Waiter(Food f) { this.f = f; } @Override public void run() { for (int i = 0; i < 100; i++) { try { Thread.sleep(100); } catch (InterruptedException e) { e.printStackTrace(); } f.get(); } } } //食物 static class Food { private String name; private String taste; //true 表示可以生产 private boolean flag = true; //只有厨师对象才会调用这个方法 public synchronized void setNameAndSaste(String name, String taste) { if (flag) { this.name = name; try { Thread.sleep(100); } catch (InterruptedException e) { e.printStackTrace(); } this.taste = taste; flag = false; this.notifyAll();//唤醒当前在this下睡着的所有线程 try { this.wait(); //唤醒以后,厨师厨师线程休眠 } catch (InterruptedException e) { e.printStackTrace(); } } } public synchronized void get() { if (!flag ) { System.out.println("服务员端走的菜d的名称是:" + name + ",味道:" + taste); flag = true;//厨师就可以重新做饭了 this.notifyAll();//唤醒 try { this.wait();//让自己休眠 } catch (InterruptedException e) { e.printStackTrace(); } } } }
线程的六种状态
线程的基本生命周期
带返回值的线程callable
Runnable 与 Callable的对比
接口定义 //Callable接口 public interface Callable<V> { V call() throws Exception; } //Runnable接口 public interface Runnable { public abstract void run(); }
Callable使用步骤
1. 编写类实现Callable接口 , 实现call方法 class XXX implements Callable<T> { @Override public <T> call() throws Exception { return T; } } 2. 创建FutureTask对象 , 并传入第一步编写的Callable类对象 FutureTask<Integer> future = new FutureTask<>(callable); 3. 通过Thread,启动线程 new Thread(future).start();
FutureTask类的方法
public static void main(String[] args) throws ExecutionException, InterruptedException { Callable<Integer> c = new MyCallable();//1.创建Callable类型的对象 FutureTask task = new FutureTask(c);//2.创建任务对象 new Thread(task).start();//3.启动线程 //当不调用get方法时,主线程和子线程是同时执行程序,现象为交替打印同样的数字 //当调用get方法时,只有等get方法执行完(即子线程执行完)后,主线程才继续执行 Integer j = (Integer) task.get(); System.out.println("返回值为:"+j); for (int i=0;i<10;i++){ try { Thread.sleep(100); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(i); } } static class MyCallable implements Callable<Integer>{ @Override public Integer call() throws Exception { //Thread.sleep(3000); for (int i=0;i<10;i++){ Thread.sleep(100); System.out.println(i); } return 100; } }
线程池
线程池:如果并发的线程数量很多,并且每个线程都是执行一个时间很短的任务就结束了,这样频繁创建线程 就会大大降低 系统的效率,因为频繁创建线程和销毁线程需要时间. 线程池就是一个容纳多个线程的容 器,池中的线程可以反复使用,省去了频繁创建线程对象的操作,节省了大量的时间和资源。
原理图
-
将任务按顺序插入到线程数组的空闲线程
-
当线程数组内的的线程都为忙碌时,线程将进行排队或者是非定长线程池进行动态扩容。
-
有些非定长线程池还有清空缓存的功能。例如一个线程在白天动态扩容到800个长度,而晚上只有80个长度被访问,那么空闲的线程将会被清空。
线程池的好处
-
降低资源消耗。
-
提高响应速度。
-
提高线程的可管理性。
Java中的四种线程池
-
缓存线程池
-
定长线程池
-
单线程线程池
-
周期性任务定长线程池
缓存线程池的实现
缓存线程池.
-
(长度无限制)
-
执行流程:
-
-
判断线程池是否存在空闲线程
-
-
存在则使用
-
-
-
不存在,则创建线程 并放入线程池, 然后使用
-
-
-
-
public static void main(String[] args) { ExecutorService service = Executors.newCachedThreadPool(); //创建缓存线程池 //指挥线程池中执行新的任务 service.execute(new Runnable() { @Override public void run() { System.out.println(Thread.currentThread().getName()+"锄禾日当午"); } }); service.execute(new Runnable() { @Override public void run() { System.out.println(Thread.currentThread().getName()+"锄禾日当午"); } }); service.execute(new Runnable() { @Override public void run() { System.out.println(Thread.currentThread().getName()+"锄禾日当午"); } }); try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } //由于缓存了1s,有线程空闲了,那么下面这个打印不会创建新的线程池,而是使用空闲的线程池 service.execute(new Runnable() { @Override public void run() { System.out.println(Thread.currentThread().getName()+"锄禾日当午"); } }); }
定长线程池的实现
定长线程池.
-
(长度是指定的数值)
-
执行流程:
-
1.判断线程池是否存在空闲线程
-
2.存在则使用
-
3.不存在空闲线程,且线程池未满的情况下,则创建线程 并放入线程池, 然后使用
-
4.不存在空闲线程,且线程池已满的情况下,则等待线程池存在空闲线程
-
public static void main(String[] args) { ExecutorService service = Executors.newFixedThreadPool(2); service.execute(new Runnable() { @Override public void run() { System.out.println(Thread.currentThread().getName()+"锄禾日当午"); try { Thread.sleep(3000); } catch (InterruptedException e) { e.printStackTrace(); } } }); service.execute(new Runnable() { @Override public void run() { System.out.println(Thread.currentThread().getName() + "锄禾日当午"); try { Thread.sleep(3000); } catch (InterruptedException e) { e.printStackTrace(); } } }); service.execute(new Runnable() { @Override public void run() { System.out.println(Thread.currentThread().getName() + "锄禾日当午"); } }); }
单线程线程池的实现
单线程线程池.
-
执行流程:
-
判断线程池 的那个线程 是否空闲
-
空闲则使用
-
不空闲,则等待 池中的单个线程空闲后 使用
public static void main(String[] args) { ExecutorService service = Executors.newSingleThreadExecutor(); service.execute(new Runnable() { @Override public void run() { System.out.println(Thread.currentThread().getName()+"锄禾日当午"); } }); service.execute(new Runnable() { @Override public void run() { System.out.println(Thread.currentThread().getName()+"锄禾日当午"); } }); service.execute(new Runnable() { @Override public void run() { System.out.println(Thread.currentThread().getName()+"锄禾日当午"); } }); service.execute(new Runnable() { @Override public void run() { System.out.println(Thread.currentThread().getName()+"锄禾日当午"); } }); }
周期性任务定长线程池
周期任务 定长线程池.
-
执行流程:
* 1. 判断线程池是否存在空闲线程
* 2. 存在则使用
* 3. 不存在空闲线程,且线程池未满的情况下,则创建线程 并放入线程池, 然后使用
* 4. 不存在空闲线程,且线程池已满的情况下,则等待线程池存在空闲线程
* 周期性任务执行时:
* 定时执行, 当某个时机触发时, 自动执行某任务 .
{ ScheduledExecutorService service = Executors.newScheduledThreadPool(2); //1.创建定长 service.schedule(new Runnable() { //2.调用线程 @Override public void run() { System.out.println("锄禾日当午"); } },5, TimeUnit.SECONDS);*/ //周期执行 /** * 周期性执行任务 * 参数1:任务 * 参数2:延迟时长数字(第一次执行在什么时间以后) * 参数3:周期时长数字(每隔多久执行一次) * 参数4:时长数字的单位 */ service.scheduleAtFixedRate(new Runnable() { @Override public void run() { System.out.println("汗滴禾下土"); } },5,1,TimeUnit.SECONDS); }
Lambda表达式
格式:函数名称(参数)—>{代码}
public static void main(String[] args) { //冗余的Runnable代码 /*Thread t = new Thread(new Runnable() { @Override public void run() { System.out.println("锄禾日当午"); } }); t.start();*/ Thread t = new Thread(() -> {System.out.println("锄禾日当午");}); //lambda表达式 t.start(); }