第八章 多线程
尚硅谷最新版Java零基础编程全套完整版(java初学者入门神器,好评如潮,宋红康主讲)
课程PPT及代码,按照视频中方式下载
DAY21
-
基本概念
- 程序 (program) 是为完成特定任务、用某种语言编写的一组指令的集合,即指一段静态的代码,静态对象。
- 进程 (process) 是程序的一次执行过程,或正在运行的一个程序。是一个 动态的过程:有它自身的产生、存在和消亡过程。——生命周期
- 线程 (thread),进程可一步细化为线程,是一个程序内部的一条执行路径。
- 若一个进程同时间并行执行多个线程,就是支持多线程的
- 线程作为调度和执行的单位,每个线程拥有独立的运行栈和程序计数器(pc),线程切换的开 销小
- 一个进程中的多线程共享相同的内存单元/内存地址空间(它们从同一堆中分配对象,可以 访问相同的变量和对象)。这就使得线程间通信更简便、高效,但多个线程操作共享系统资源可能就会带来安全的隐患 。
- 并行与并发
- 并行: 多个CPU同时执行多个任务。比如:多个人做不的事,同时执行多个任务。
- 并发:一个CPU(采用时间片)同时执行多个任务。 比如:秒杀、多个人做同一件事。
- 何时需要多线程
- 程序需要同时执行两个或多任务。
- 程序需要实现一些等待的任务时,如用户输入、文件读写操作、网络操作、搜索等。
- 需要一些后台运行的程序时。
-
多线程的创建
-
方式一:继承于Thread类
1.创建一个继承于Thread类的子类
2.重写Thread类的run() -->将此线程执行的操作声明在run()中
3.创建Thread类的子类的对象
4.调用此对象的start()
-
若只调用一次,也可使用Thread类的匿名子类
package com.atguigu.java; /** * 创建多线程,方式一:继承于Thread类 * 例:遍历100以内的偶数 * @author quanquan * @create 2020-03-27-20:29 */ public class ThreadTest { public static void main(String[] args) { Mythread mythread = new Mythread(); mythread.start(); //1.启动当前线程 2.调用当前线程的run() //不能通过直接调用run()方法启动线程; // 不能让已经start()的线程去执行,会报IllegalThreadStateException;需要新建线程对象 // 使用匿名子类 // new Thread(){ // @Override // public void run() { // for (int i = 0; i < 100; i++) { // if (i%2 == 0){ // System.out.println(Thread.currentThread().getName()+":"+i); // } // } // } // }.start(); //如下操作仍然是在main线程中执行的 for (int s = 0; s < 100; s++) { if (s % 2 == 0) { System.out.println(s + "****"); } } } } class Mythread extends Thread{ @Override public void run() { for (int i = 0; i < 100; i++) { if (i%2 == 0){ System.out.println(i); } } } }
- Thread类有关方法
- static void yield():线程让步
- join():当某线程a调用线程b的 join() 方法时,线程a进入阻塞状态,直到线程b执行完,线程a才结束阻塞状态
- sleep(long millitime):让当前线程”睡眠“指定的millitime毫秒
- isAlive():判断当前线程是否存活
-
-
线程的优先级
- MAX_PRIORITY:10
- MIN_PRIORITY:1
- NORM_PRIORITY:5
- getPriority():返回线程优先级
- setPriority(int newPriority):改变线程的优先级
- 说明:高优先级的线程要抢占低优先级线程cpu的执行权。但是只是从概率上讲,高优先级的线程高概率被执行,并不意味着只有当优先级高的线程执行完后,低优先级的线程才执行。
DAY22
-
方式二:实现Runnable接口
- 创建一个实现Runnable接口的类
- 实现类去实现Runnable中的抽象方法:run()
- 创建实现类的对象
- 将此对象作为参数传递到Thread类的构造器中,创建Thread类的对象
- 通过Thread类的对象调用start()
package com.atguigu.java; /** * @author quanquan * @create 2020-03-28-10:37 */ public class ThreadTest2 { public static void main(String[] args) { //3. 创建实现类的对象 MThread mThread = new MThread(); //4. 将此对象作为参数传递到Thread类的构造器中,创建Thread类的对象 Thread t1 = new Thread(mThread); t1.setName("线程1"); //5. 通过Thread类的对象调用start():① 启动线程 ②调用当前线程的run()-->调用了Runnable类型的target的run() t1.start(); //再启动一个线程,遍历100以内的偶数 Thread t2 = new Thread(mThread); t2.setName("线程2"); t2.start(); } } //1.创建Runnable接口的实现类 class MThread implements Runnable{ //2. 实现类去实现Runnable中的抽象方法:run() @Override public void run() { for (int i = 0; i < 100; i++) { if(i % 2 == 0){ System.out.println(Thread.currentThread().getName() + ":" + i); } } } }
-
比较创建线程的两种方法
-
开发中优先选择实现Runnable接口方式
原因:1.实现的方式没有类的单继承限制
2.实现的方式更适合来处理多个线程有共享数据的情况
-
二者联系:
1.public class Thread implements Runnable
2.两种方式都需要重写run()方法,将线程要执行的逻辑声明在run()中
-
每日一考day01
package com.atguigu.java;
/**
* @author quanquan
* @create 2020-03-28-11:13
*/
public class Test2 {
public static void main(String[] args) {
BianLi bianli = new BianLi();
bianli.start();
}
}
class BianLi extends Thread{
@Override
public void run() {
for (int i=0;i<100;i++){
System.out.println(getName()+":"+i);
}
}
}
package com.atguigu.java;
/**
* @author quanquan
* @create 2020-03-28-11:20
*/
public class Test3 {
public static void main(String[] args) {
BianLi2 bianli2 = new BianLi2();
Thread t = new Thread(bianli2);
t.start();
}
}
class BianLi2 implements Runnable{
@Override
public void run() {
for (int i=0;i<100;i++){
System.out.println(Thread.currentThread().getName()+":"+i);
}
}
}
- Java中的线程分为两类:守护线程和用户线程
- 守护线程是用来服务用户线程的,通过在start()方法前调用thread.setDaemon(true)可以把一个用户线程变成一个守护线程
- 若JVM中都是守护线程,当前JVM将退出
- 线程的生命周期:新建,就绪,运行,阻塞,死亡
-
线程的同步
例子:创建三个窗口卖票,总票数为100张。
-
问题:卖票过程中,出现了重票、错票 -->出现了线程的安全问题
-
问题出现的原因:当某个线程操作车票的过程中,尚未操作完成时,其他线程参与进来,也操作车票
-
如何解决:当一个线程a在操作ticket时,其他线程不能参与进来。直到线程a操作完ticket时,其他线程才开始操作ticket。这种情况即使线程a出现了阻塞,也不能被改变
-
在java中,通过同步机制,来解决安全问题
-
方式一:同步代码块
synchronized(同步监视器){
//需要被同步的代码
}
说明:1.操作共享数据的代码,即为需要被同步的代码 -->包含的代码不能多也不能少
2.共享数据:多个线程共同操作的变量。比如:ticket就是共享数据
3.同步监视器:俗称:锁。任何一个类的对象,都可以充当锁。
要求:多个线程必须要共用同一把锁
补充:在实现Runnable接口创建多线程的方式中,我们可以考虑使用this充当同步监视器。
package com.atguigu.java; /** * 使用同步代码块解决实现Runnable接口的方式的线程安全问题 */ class Window1 implements Runnable{ private int ticket = 100; @Override public void run() { // Object obj = new Object(); while(true){ synchronized (this){//此时的this:唯一的Window1的对象 //方式二:synchronized (dog) { if (ticket > 0) { try { Thread.sleep(100); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(Thread.currentThread().getName() + ":卖票,票号为:" + ticket); ticket--; } else { break; } } } } } public class WindowTest1 { public static void main(String[] args) { Window1 w = new Window1(); Thread t1 = new Thread(w); Thread t2 = new Thread(w); Thread t3 = new Thread(w); t1.setName("窗口1"); t2.setName("窗口2"); t3.setName("窗口3"); t1.start(); t2.start(); t3.start(); } } class Dog{ }
package com.atguigu.java; /** * 使用同步代码块解决继承Thread类的方式的线程安全问题 * * 说明:在继承Thread类创建多线程的方式中,慎用this充当同步监视器,考虑使用当前类充当同步监视器 */ class Window2 extends Thread{ private static int ticket = 100; private static Object obj = new Object(); @Override public void run() { while(true){ //正确的 // synchronized (obj){ synchronized (Window2.class){//Class clazz = Window2.class, Window2.class只会加载一次 //错误的方式:this代表着t1,t2,t3三个对象 // synchronized (this){ if(ticket > 0){ try { Thread.sleep(100); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(getName() + ":卖票,票号为:" + ticket); ticket--; }else{ break; } } } } } public class WindowTest2 { public static void main(String[] args) { Window2 t1 = new Window2(); Window2 t2 = new Window2(); Window2 t3 = new Window2(); t1.setName("窗口1"); t2.setName("窗口2"); t3.setName("窗口3"); t1.start(); t2.start(); t3.start(); } }
-
方式二:同步方法
如果操作共享数据的代码完整声明在一个方法中,我们不妨将此方法声明同步
总结:1.同步方法仍然涉及到同步监视器,只是不需要我们显示声明
2.非静态的同步方法,同步监视器:this
静态的同步方法,同步监视器:当前类本身
package com.atguigu.java; /** * 使用同步方法解决实现Runnable接口的线程安全问题 * * @author quanquan * @create 2020-03-28-18:03 */ class Window3 implements Runnable { private int ticket = 100; @Override public void run() { while (true) { show(); } } private synchronized void show(){ if (ticket > 0) { try { Thread.sleep(100); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(Thread.currentThread().getName() + ":卖票,票号为:" + ticket); ticket--; }else{ Thread.currentThread().stop(); // break; } } } public class WindowTest3 { public static void main(String[] args) { Window3 w = new Window3(); Thread t1 = new Thread(w); Thread t2 = new Thread(w); Thread t3 = new Thread(w); t1.setName("窗口1"); t2.setName("窗口2"); t3.setName("窗口3"); t1.start(); t2.start(); t3.start(); } }
package com.atguigu.java; /** * 使用同步方法处理继承Thread累的方式中的线程安全问题 * @author quanquan * @create 2020-03-28-19:51 */ class Window4 extends Thread { private static int ticket = 100; @Override public void run() { while (true) { show(); } } private static synchronized void show(){ //同步监视器:window4.class // private synchronized void show(){ //同步监视器:t1,t2,t3,此种解决方式是错误的 if (ticket > 0) { try { Thread.sleep(100); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(Thread.currentThread().getName() + ":卖票,票号为:" + ticket); ticket--; } } } public class WindowTest4 { public static void main(String[] args) { Window4 t1 = new Window4(); Window4 t2 = new Window4(); Window4 t3 = new Window4(); t1.setName("窗口1"); t2.setName("窗口2"); t3.setName("窗口3"); t1.start(); t2.start(); t3.start(); } }
-
优点:同步的方式,解决线程的安全问题
局限性:操作同步代码时,只能有一个线程参与,其他 线程等待。相当于是一个单线程的过程,效率低
-
-
-
单例模式懒汉式,线程不安全
public class BankTest {
}
class Bank{
private Bank(){}
private static Bank instance = null;
public static Bank getInstance(){
synchronized (Bank.class) {
if(instance == null){
instance = new Bank();
}
return instance;
}
}
}
使用同步机制将单例模式中的懒汉式改写为线程安全的
public class BankTest {
}
class Bank{
private Bank(){}
private static Bank instance = null;
public static Bank getInstance(){
//方式一:效率稍差
// synchronized (Bank.class) {
// if(instance == null){
//
// instance = new Bank();
// }
// return instance;
// }
//方式二:效率更高
if(instance == null){
synchronized (Bank.class) {
if(instance == null){
instance = new Bank();
}
}
}
return instance;
}
}
-
线程的死锁问题
- 不同的线程分别占用对方需要的同步资源不放弃,都在等待对方放弃自己需要的同步资源,就形成了线程的死锁
- 出现死锁后,不会出现异常,不会出现提示,只是所有的线程都处于阻塞状态,无法继续
-
解决线程安全问题的方式三:Lock(同步锁)—JDK5.0新增
-
面试题:synchronized 与 Lock的异同?
相同:二者都可以解决线程安全问题
不同:synchronized机制在执行完相应的同步代码以后,自动的释放同步监视器
Lock需要手动的启动同步(lock()),同时结束同步也需要手动的实现(unlock())
-
优先使用顺序:
Lock -> 同步代码块(已经进入了方法体,分配了相应资源)-> 同步方法(在方法体之外)
-
class Window implements Runnable{
private int ticket = 100;
//1.实例化ReentrantLock
private ReentrantLock lock = new ReentrantLock();
@Override
public void run() {
while(true){
try{
//2.调用锁定方法lock()
lock.lock();
if(ticket > 0){
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + ":售票,票号为:" + ticket);
ticket--;
}else{
break;
}
}finally {
//3.调用解锁方法:unlock()
lock.unlock();
}
}
}
}
public class LockTest {
public static void main(String[] args) {
Window w = new Window();
Thread t1 = new Thread(w);
Thread t2 = new Thread(w);
Thread t3 = new Thread(w);
t1.setName("窗口1");
t2.setName("窗口2");
t3.setName("窗口3");
t1.start();
t2.start();
t3.start();
}
}
-
线程通信
- 涉及三个方法:
- wait():一旦执行此方法,当前线程就进入阻塞状态,并释放同步监视器。
- notify():一旦执行此方法,就会唤醒被wait的一个线程。如果有多个线程被wait,就唤醒优先级高的那个。
- notifyAll():一旦执行此方法,就会唤醒所有被wait的线程。
- 说明:
- 1.wait(),notify(),notifyAll()三个方法必须使用在同步代码块或同步方法中。
- 2.wait(),notify(),notifyAll()三个方法的调用者必须是同步代码块或同步方法中的同步监视器。否则,会出现IllegalMonitorStateException异常
- 3.wait(),notify(),notifyAll()三个方法是定义在java.lang.Object类中
- 涉及三个方法:
-
面试题:sleep() 和 wait()的异同?
-
1.相同点:一旦执行方法,都可以使得当前的线程进入阻塞状态。
-
2.不同点:
1)两个方法声明的位置不同:Thread类中声明sleep() , Object类中声明wait()
2)调用的要求不同:sleep()可以在任何需要的场景下调用。 wait()必须使用在同步代码块或同步方法中
3)关于是否释放同步监视器:如果两个方法都使用在同步代码块或同步方法中,sleep()不会释放锁,wait()会释放锁。
-
DAY23
-
JDK5.0新增线程创建方式
- 新增方式一:实现Callable接口
- 如何理解实现Callable接口的方式创建多线程比实现Runnable接口创建多线程方式强大?
- call()可以有返回值的。
- call()可以抛出异常,被外面的操作捕获,获取异常的信息
- Callable是支持泛型的
package com.atguigu.java; import java.util.concurrent.Callable; import java.util.concurrent.ExecutionException; import java.util.concurrent.FutureTask; /** * 创建线程的方式三:实现Callable接口。 * @author quanquan * @create 2020-03-29-10:38 */ //1.创建一个实现Callable的实现类 class NumThread implements Callable{ //2.实现call方法,将此线程需要执行的操作声明在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); sum += i; } } return sum; } } public class ThreadNew { public static void main(String[] args) { //3.创建Callable接口实现类的对象 NumThread numThread = new NumThread(); //4.将此Callable接口实现类的对象作为传递到FutureTask构造器中,创建FutureTask的对象 FutureTask futureTask = new FutureTask(numThread); //5.将FutureTask的对象作为参数传递到Thread类的构造器中,创建Thread对象,并调用start() new Thread(futureTask).start(); try { //6.获取Callable中call方法的返回值 //get()返回值 即为FutureTask构造器参数Callable实现类重写的call()的返回值。 Object sum = futureTask.get(); System.out.println("总和为:"+sum); } catch (InterruptedException e) { e.printStackTrace(); } catch (ExecutionException e) { e.printStackTrace(); } } }
-
新增方式二:使用线程池
好处:
-
1.提高响应速度(减少了创建新线程的时间)
-
2.降低资源消耗(重复利用线程池中线程,不需要每次都创建)
-
3.便于线程管理
corePoolSize:核心池的大小
maximumPoolSize:最大线程数
keepAliveTime:线程没有任务时最多保持多长时间后会终止
-
package com.atguigu.java; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; import java.util.concurrent.ThreadPoolExecutor; /** * @author quanquan * @create 2020-03-29-11:39 */ class NumberThread implements Runnable{ @Override public void run() { for(int i = 0;i <= 100;i++){ if(i % 2 == 0){ System.out.println(Thread.currentThread().getName() + ": " + i); } } } } class NumberThread1 implements Runnable{ @Override public void run() { for(int i = 0;i <= 100;i++){ if(i % 2 != 0){ System.out.println(Thread.currentThread().getName() + ": " + i); } } } } public class ThreadPool { public static void main(String[] args) { //1. 提供指定线程数量的线程池 ExecutorService service = Executors.newFixedThreadPool(10); ThreadPoolExecutor service1 = (ThreadPoolExecutor) service; //设置线程池的属性 // System.out.println(service.getClass()); // service1.setCorePoolSize(15); // service1.setKeepAliveTime(); //2.执行指定的线程的操作。需要提供实现Runnable接口或Callable接口实现类的对象 service.execute(new NumberThread());//适合适用于Runnable service.execute(new NumberThread1());//适合适用于Runnable // service.submit(Callable callable);//适合使用于Callable //3.关闭连接池 service.shutdown(); } }
-
面试题:创建多线程有几种方式?四种!