多线程的引入(了解)
什么是线程
- 线程是程序执行的一条路径,一个进程中可以包含多条线程
- 多线程并发执行可以提高程序的效率,可以同时完成多项工作
多线程的应用场景
- 红蜘蛛同时共享屏幕给多个电脑
- 迅雷开启多条线程一起下载
- QQ同时和多个人一起视频
- 服务器同时处理多个客户端请求
多线程并行和并发的区别(了解)
并行就是两个任务同时运行,就是甲任务进行的同时,乙任务也在进行。(需要多核CPU)
并发是指两个任务都请求运行,而处理器只能按受一个任务,就把这两个任务安排轮流进行,由于时间间隔较短,使人感觉两个任务都在运行。
比如我跟两个网友聊天,左手操作一个电脑跟甲聊,同时右手用另一台电脑跟乙聊天,这就叫并行。
如果用一台电脑我先给甲发个消息,然后立刻再给乙发消息,然后再跟甲聊,再跟乙聊。这就叫并发。
java程序运行原理和JVM的启动是多线程的吗?(了解)
java程序运行原理
java命令会启动java虚拟机,启动JVM,等于启动了一个应用程序,也就是启动了一个进程,该进程会自动启动一个"主线程",然后主线程去调用某个类的main方法。
JVM的启动是多线程的吗
JVM启动至少启动了垃圾回收线程和主线程,所以是多线程的
。
多线程实现方式一(掌握)
继承Thread类
- 自定义类继承Thread
- 重写run方法
- 把新线程要做的事写在run方法中
- 开启新线程,内部会自动执行run方法
package com.heima.thread;
public class Demo1_Thread {
public static void main(String[] args) {
MyThread mt = new MyThread(); // 4、创建Thread类的子类对象
mt.start(); // 5、开启线程
for (int i = 0; i < 1000; i++) {
System.out.println("bb");
}
}
}
class MyThread extends Thread {
// 1、继承Thread类
public void run() {
// 2、重写run方法
for (int i = 0; i < 1000; i++) {
// 3、将要执行的代码写在run方法中
System.out.println("aaaaaaaaaaaaa");
}
}
}
多线程实现方式二(掌握)
实现Runnable接口
- 定义类实现Runnable接口
- 实现run方法
- 把新线程要做的事写在run方法中
- 创建自定义的Runnable的子类对象
- 创建Thread对象,传入Runnable
- 调用start方法开启线程,内部会自动调用Runnable的run方法
package com.heima.thread;
public class Demo2_Runnable {
public static void main(String[] args) {
MyRunnable mr = new MyRunnable(); // 4,创建Runnable的子类对象
Thread t1 = new Thread(mr); // 5,将其当作参数传递给Thread的构造函数
t1.start(); // 6,开启线程
for (int i = 0; i < 1000; i++) {
System.out.println("bb");
}
}
}
class MyRunnable implements Runnable {
// 1,定义一个类实现Runnable
@Override
public void run() {
// 2,重写run方法
for (int i = 0; i < 1000; i++) {
System.out.println("aaaaaaaaaaaaa"); // 3,将要执行的代码写在run方法中
}
}
}
实现Runnable的原理(了解)
查看源码
- 看Thread类的构造函数,传递了Runnable接口的引用
- 通过init()方法找到传递的target给成员变量的target赋值
- 查看run方法,发现run方法中有判断,如果target不为null,就会调用Runnable接口子类对象的run()方法
两种方式的区别(掌握)
查看源码的区别
- 继承
Thread
:由于子类重写了Thread类的run()
方法,当调用start()
方法时,直接找子类的run()
方法。 - 实现
Runnable
:构造函数中传入了Runnable
的引用,成员变量记住了它,start()
方法调用run()
方法时内部判断成员变量Runnable的引用是否为空,不为空编译时看的是Runnable的run()
方法,运行时执行的是子类的run()
方法。
继承Thread
- 好处:可以直接使用Thread类中的方法,代码简单
- 弊端:如果已经有了父类,就不能用这种方法
实现Runnable接口
- 好处:即使自己定义的线程类有了父类也没关系,因为有了父类也可以实现接口,而且接口是可以多实现的
- 弊端:不能直接使用Thread中的方法需要先获取到线程对象后,才能得到Thread的方法,代码复杂
匿名内部类实现线程的两种方式(掌握)
- 继承Thread类
- 实现Runnable接口
package com.heima.thread;
public class Demo3_Thread {
public static void main(String[] args) {
new Thread() {
// 1、继承Thread类
public void run() {
// 2、重写run()方法
for (int i = 0; i < 1000; i++) {
// 3、将要执行的代码写在run()方法中
System.out.println("aaaaaaaaaaaaa");
}
}
}.start(); // 4、开启线程
new Thread(new Runnable() {
// 1、将Runnable的子类对象传递给Thread的构造方法
public void run() {
// 2、重写run()方法
for (int i = 0; i < 1000; i++) {
// 3、将要执行的代码写在run()方法中
System.out.println("bb");
}
}
}).start(); // 4、开启线程
}
}
获取名字和设置名字(掌握)
- 获取名字:通过
getName()
方法获取线程对象的名字 - 设置名字:通过构造函数可以传入String类型的名字
- 通过
setName(String)
方法可以设置线程对象的名字
package com.heima.threadmethod;
public class Demo1_Thread {
public static void main(String[] args) {
demo1();
Thread t1 = new Thread() {
@Override
public void run() {
System.out.println(this.getName() + "....aaaaaa");
}
};
Thread t2 = new Thread() {
@Override
public void run() {
System.out.println(this.getName() + "....bb");
}
};
t1.setName("张三");
t2.setName("李四");
t1.start();
t2.start();
}
private static void demo1() {
new Thread("芙蓉姐姐") {
// 通过构造方法给name赋值
@Override
public void run() {
System.out.println(this.getName() + "...aaaaaaaaaa");
}
}.start();
new Thread("凤姐") {
// 通过构造方法给name赋值
@Override
public void run() {
System.out.println(this.getName() + "...bb");
}
}.start();
}
}
获取当前线程的对象(掌握)
Thread.currentThread(),
主线程也可以获取
package com.heima.threadmethod;
public class Demo2_Thread {
public static void main(String[] args) {
new Thread() {
public void run() {
System.out.println(getName() + "....aaaaaaaa");
}
}.start();
new Thread(new Runnable() {
@Override
public void run() {
// Thread.currentThread()获取当前正在执行的线程
System.out.println(Thread.currentThread().getName() + "...bb");
}
}).start();
Thread.currentThread().setName("我是主线程");
System.out.println(Thread.currentThread().getName());
}
}
休眠线程(掌握)
Thread.sleep(毫秒,纳秒)
, 控制当前线程休眠若干毫秒1秒= 1000毫秒 1秒 = 1000 * 1000 * 1000纳秒 1000000000
package com.heima.threadmethod;
public class Demo3_Thread {
public static void main(String[] args) throws InterruptedException {
// demo1();
new Thread() {
public void run() {
for (int i = 0; i < 10; i++) {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(getName() + "...aaaaaaaaaa");
}
}
}.start();
new Thread() {
public void run() {
for (int i = 0; i < 10; i++) {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(getName() + "...bb");
}
}
}.start();
}
private static void demo1() throws InterruptedException {
for (int i = 20; i >= 0; i--) {
Thread.sleep(1000);
System.out.println("倒计时第" + i + "秒");
}
}
}
守护线程(掌握)
setDaemon()
, 设置一个线程为守护线程, 该线程不会单独执行, 当其他非守护线程都执行结束后, 自动退出
package com.heima.threadmethod;
public class Demo4_Thread {
public static void main(String[] args) {
Thread t1 = new Thread() {
public void run() {
for (int i = 0; i < 2; i++) {
System.out.println(getName() + "...aaaaaaaa");
}
}
};
Thread t2 = new Thread() {
public void run() {
for (int i = 0; i < 10; i++) {
System.out.println(getName() + "...bb");
}
}
};
t2.setDaemon(true); // 设置为守护线程
t1.start();
t2.start();
}
}
加入线程(了解)
join(),
当前线程暂停, 等待指定的线程执行结束后, 当前线程再继续join(int),
可以等待指定的毫秒之后继续
package com.heima.threadmethod;
public class Demo5_Join {
/*
* join()当前线程暂停,等待指定的线程执行结束后,当前线程再继续
*/
public static void main(String[] args) {
final Thread t1 = new Thread() {
public void run() {
for (int i = 0; i < 10; i++) {
System.out.println(getName() + "...aaaaaaaaa");
}
}
};
Thread t2 = new Thread() {
public void run() {
for (int i = 0; i < 10; i++) {
if (i == 2) {
try {
t1.join(); // 插队指定的时间,过了指定时间后,两条线程交替执行
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println(getName() + "...bb");
}
}
};
t1.start();
t2.start();
}
}
礼让线程(了解)
yield让出cpu
package com.heima.threadmethod;
public class Demo6_Yield {
public static void main(String[] args) {
new MyThread().start();
new MyThread().start();
}
}
class MyThread extends Thread {
public void run() {
for (int i = 1; i <= 1000; i++) {
if (i % 10 == 0) {
Thread.yield(); // 让出CPU
}
System.out.println(getName() + "..." + i);
}
}
}
设置线程的优先级(了解)
setPriority()
设置线程的优先级
package com.heima.threadmethod;
public class Demo7_Priority {
public static void main(String[] args) {
Thread t1 = new Thread() {
public void run() {
for (int i = 0; i < 1000; i++) {
System.out.println(getName() + "...aaaaaaa");
}
}
};
Thread t2 = new Thread() {
public void run() {
for (int i = 0; i < 1000; i++) {
System.out.println(getName() + "...bb");
}
}
};
// t1.setPriority(1);
// t2.setPriority(10); //设置最大优先级
t1.setPriority(Thread.MAX_PRIORITY); // 设置最大的线程优先级
t2.setPriority(Thread.MIN_PRIORITY); // 设置最小的线程优先级
t1.start();
t2.start();
}
}
同步代码块(掌握)
什么情况下需要同步
- 当多线程并发,有多段代码同时执行时,我们希望一段代码执行的过程中CPU不要切换到其他线程工作,这时就需要同步
- 如果两段代码是同步的,那么同一时间只能执行一段,在一段代码执行结束之前,不会执行另一段代码。
同步代码块
- 使用关键字
synchronized
关键字加上一个锁对象来定义一段代码,这就叫同步代码块 - 多个同步代码块如果使用相同的锁对象,那么他们就是同步的
package com.heima.sync;
public class Demo1_Synchronized {
/*
* 同步代码块
*/
public static void main(String[] args) {
final Printer p = new Printer();
new Thread() {
public void run() {
while (true) {
p.print1();
}
}
}.start();
new Thread() {
public void run() {
while (true) {
p.print2();
}
}
}.start();
}
}
class Printer {
Demo d = new Demo();
public void print1() {
synchronized (d) {
// 同步代码块,锁机制,锁对象可以是任意的
System.out.print("黑");
System.out.print("马");
System.out.print("程");
System.out.print("序");
System.out.print("员");
System.out.print("\r\n");
}
}
public void print2() {
// synchronized(new Demo()) { //锁对象不能用匿名对象,因为匿名对象不是同一个对象
synchronized (d) {
System.out.print("传");
System.out.print("智");
System.out.print("播");
System.out.print("客");
System.out.print("\r\n");
}
}
}
class Demo {
}
同步方法(掌握)
- 使用
synchronized
关键字修饰一个方法, 该方法中所有的代码都是同步的 - 非静态同步函数的锁是:
this
- 静态的同步函数的锁是:字节码对象
package com.heima.sync;
public class Demo2_Synchronized {
/*
* 同步代码块
*/
public static void main(String[] args) {
final Printer2 p = new Printer2();
new Thread() {
public void run() {
while (true) {
p.print1();
}
}
}.start();
new Thread() {
public void run() {
while (true) {
p.print2();
}
}
}.start();
}
}
class Printer2 {
// 非静态的同步方法的锁对象是什么?
// 答:非静态的同步方法的锁对象是this
// 静态同步方法的锁对象是什么?
// 答:静态同步方法的锁对象是该类的字节码对象
public static synchronized void print1() {
// 同步方法只需要在方法上加synchronized关键字即可
// synchronized (this) { // 非静态的同步方法的锁对象是this
System.out.print("黑");
System.out.print("马");
System.out.print("程");
System.out.print("序");
System.out.print("员");
System.out.print("\r\n");
}
public void print2() {
// synchronized(new Demo()) { //锁对象不能用匿名对象,因为匿名对象不是同一个对象
// synchronized (this) { // 非静态的同步方法的锁对象是this
synchronized (Printer2.class) {
System.out.print("传");
System.out.print("智");
System.out.print("播");
System.out.print("客");
System.out.print("\r\n");
}
}
}
线程安全问题(掌握)
- 多线程并发操作同一数据时, 就有可能出现线程安全问题
- 使用同步技术可以解决这种问题, 把操作数据的代码进行同步, 不要多个线程一起操作
package com.heima.sync;
public class Tickets {
/*
* 需求:铁路售票,一共100张,通过四个窗口卖完.
*/
public static void main(String[] args) {
new Ticket().start();
new Ticket().start();
new Ticket().start();
new Ticket().start();
}
}
class Ticket extends Thread {
private static int ticket = 100;
// private static Object obj = new Object(); //如果用引用数据类型成员变量当作锁对象,必须是静态的
public void run() {
while (true) {
synchronized (Ticket.class) {
if (ticket <= 0) {
break;
}
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(getName() + "这是第" + ticket-- + "号票");
}
}
}
}
火车站卖票的例子用实现Runnable接口(掌握)
package com.heima.sync;
public class Demo4_Tickets {
/*
* 火车站卖票的例子用实现Runnable接口
*/
public static void main(String[] args) {
MyTicket mt = new MyTicket();
new Thread(mt).start();
new Thread(mt).start();
new Thread(mt).start();
new Thread(mt).start();
}
}
class MyTicket implements Runnable {
private int ticket = 100;
public void run() {
while (true) {
synchronized (this) {
if (ticket <= 0) {
break;
}
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "这是第" + ticket-- + "号票");
}
}
}
}
死锁(了解)
- 多线程同步的时候, 如果同步代码嵌套, 使用相同锁, 就有可能出现死锁
- 尽量不要嵌套使用
package com.heima.sync;
public class DeadLock {
/**
* @param args
*/
private static String s1 = "筷子左";
private static String s2 = "筷子右";
public static void main(String[] args) {
new Thread() {
public void run() {
while (true) {
synchronized (s1) {
System.out.println(getName() + "...获取" + s1 + "等待" + s2);
synchronized (s2) {
System.out.println(getName() + "...拿到" + s2 + "开吃");
}
}
}
}
}.start();
new Thread() {
public void run() {
while (true) {
synchronized (s2) {
System.out.println(getName() + "...获取" + s2 + "等待" + s1);
synchronized (s1) {
System.out.println(getName() + "...拿到" + s1 + "开吃");
}
}
}
}
}.start();
}
}
以前的线程安全的类回顾(掌握)
- 回顾以前说过的线程安全问题
- 看源码:Vector,StringBuffer,Hashtable,Collections.synchroinzed(xxx)
Vector是线程安全的,ArrayList是线程不安全的
StringBuffer是线程安全的,StringBuilder是线程不安全的
Hashtable是线程安全的,HashMap是线程不安全的
总结
多线程两种实现方式
继承thread
- 定义类继承Thread
- 重写run方法
- 把新线程要做的事写在run方法中
- 创建线程对象
- 开启新线程, 内部会自动执行run方法
实现Runnable
- 定义类实现Runnable接口
- 实现run方法
- 把新线程要做的事写在run方法中
- 创建自定义的Runnable的子类对象
- 创建Thread对象, 传入Runnable
- 调用start()开启新线程, 内部会自动调用Runnable的run()方法
多线程的安全问题及解决方案
- 问题:当多线程并发, 有多段代码同时执行时,数据会产生错乱。
- 方案:我们希望某一段代码执行的过程中CPU不要切换到其他线程工作. 这时就需要同步。
死锁的产生原理
- 多线程同步的时候, 如果同步代码嵌套, 使用相同锁, 就有可能出现死锁
多线程两种实现方式的区别
实现原理
继承Thread
- 由于子类重写了Thread类的run(), 当调用start()时, 直接找子类的run()方法
实现Runnable
- 构造函数中传入了Runnable的引用, 成员变量记住了它, start()调用run()方法时内部判断成员变量Runnable的引用是否为空, 不为空编译时看的是Runnable的run(),运行时执行的是子类的run()方法
优缺点
继承Thread
- 好处:可以直接使用Thread类中的方法,代码简单
- 弊端:如果已经有了父类,就不能用这种方法
实现Runnable
- 好处: 即使自己定义的线程类有了父类也没关系,因为有了父类也可以实现接口,而且接口是可以多实现的
- 弊端: 不能直接使用Thread中的方法需要先获取到线程对象后,才能得到Thread的方法,代码复杂
单例设计模式
单例设计模式:保证类在内存中只有一个对象。
如何保证类在内存中只有一个对象呢?
- 控制类的创建,不让其他类来创建本类的对象。
private
- 在本类中定义一个本类的对象,
Singgleton s;
- 提供公共的访问方式,
public static Singleton getInstance(){return s}
单例写法两种
饿汉式 开发用这种方式
package com.heima.singleton;
public class Demo1_Singleton {
public static void main(String[] args) {
Singleton s1 = Singleton.getInstance();
Singleton s2 = Singleton.getInstance();
System.out.println(s1 == s2);// 结果为true
}
}
/*
* 饿汉式
*/
class Singleton {
// 1、私有构造函数,其它类不能访问该构造函数
private Singleton() {
}
// 2、创建本类对象
private static Singleton s = new Singleton();
// 3、对外提供公共的访问方法
public static Singleton getInstance() {
return s;
}
}
懒汉式 面试写这种方式,多线程的问题
package com.heima.singleton;
public class Demo2_Singleton {
public static void main(String[] args) {
Singleton1 s1 = Singleton1.getInstance();
Singleton1 s2 = Singleton1.getInstance();
System.out.println(s1 == s2);// 结果为true
}
}
/*
* 懒汉式,单例延迟加载模式
*/
class Singleton1 {
// 1、私有构造函数
private Singleton1() {
};
// 声明一个本类的引用
private static Singleton1 s;
// 3、对外提供公共的访问方法
public static Singleton1 getInstance() {
if (s == null) {
s = new Singleton1();
}
return s;
}
}
饿汉式和懒汉式的区别
1,饿汉式是空间换时间,懒汉式是时间换空间
2,在多线程访问时,饿汉式不会创建多个对象,而懒汉式有可能会创建多个对象
第三种格式
class Singleton {
//1,私有构造方法,其他类不能访问该构造方法了
private Singleton(){
}
//2,声明一个引用
public static final Singleton s = new Singleton();//final是最终的意思,被final修饰的变量不可以被更改
}
Runtime类
- Runtime类是一个单例类
package com.heima.singleton;
import java.io.IOException;
public class Demo_Runtime {
public static void main(String[] args) throws IOException {
Runtime r = Runtime.getRuntime(); // 获取运行时对象
// r.exec("shutdown -s -t 300");
r.exec("shutdown -a");
}
}
Timer(掌握)
- Timer类:计时器
package com.heima.singleton;
import java.util.Date;
import java.util.Timer;
import java.util.TimerTask;
public class Demo3_Timer {
public static void main(String[] args) throws InterruptedException {
Timer t = new Timer();
// 在指定时间安排指定任务
// 第一个参数,是安排的任务,第二个参数是执行的时间,第三个参数是过多长时间再重复执行
t.schedule(new MyTimerTask(), new Date(188, 6, 1, 14, 22, 50), 3000);
while (true) {
Thread.sleep(1000);
System.out.println(new Date());
}
}
}
class MyTimerTask extends TimerTask {
@Override
public void run() {
System.out.println("起床背英语单词");
}
}
两个线程间的通信(掌握)
什么时候需要通信
- 多个线程并发执行时,在默认情况下CPU是随机切换线程的。
- 如果我们希望他们有规律的执行,就可以使用通信,例如每个线程执行一次打印
怎么通信
- 如果希望线程等待,就调用wait();
- 如果希望唤醒等待的线程,就调用notify();
- 这两个方法必须在同步代码块中执行,并且使用同步锁对象来调用
package com.heima.thread2;
public class Demo1_Notify {
/**
* 等待唤醒机制
*/
public static void main(String[] args) {
final Printer p = new Printer();
new Thread() {
public void run() {
while (true) {
try {
p.print1();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}.start();
new Thread() {
public void run() {
while (true) {
try {
p.print2();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}.start();
}
}
// 等待唤醒机制
class Printer {
private int flag = 1;
public void print1() throws InterruptedException {
synchronized (this) {
if (flag != 1) {
this.wait(); // 当前线程等待
}
System.out.print("黑");
System.out.print("马");
System.out.print("程");
System.out.print("序");
System.out.print("员");
System.out.print("\r\n");
flag = 2;
this.notify(); // 随机唤醒单个等待的线程
}
}
public void print2() throws InterruptedException {
synchronized (this) {
if (flag != 2) {
this.wait();
}
System.out.print("传");
System.out.print("智");
System.out.print("播");
System.out.print("客");
System.out.print("\r\n");
flag = 1;
this.notify();
}
}
}
三个或三个以上线程通信
多个线程通信的问题
- notify()方法是随机唤醒一个线程
- notifyAll()方法是唤醒所有线程
- JDK5之前无法唤醒指定的一个线程
- 如果多个线程之间通信,需要使用notifyAll()通知所有线程,用while来反复判断条件
package com.heima.thread2;
public class Demo2_NotifyAll {
public static void main(String[] args) {
final Printer2 p2 = new Printer2();
new Thread() {
public void run() {
while (true) {
try {
p2.print1();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}.start();
new Thread() {
public void run() {
while (true) {
try {
p2.print2();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}.start();
new Thread() {
public void run() {
while (true) {
try {
p2.print3();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}.start();
}
}
/*
* 1、在同步代码块中,用哪个对象锁,就用哪个对象调用wait方法
* 2、为什么wait方法和notify方法定义在Object这类中?
* 因为锁对象可以是任意对象,Object是所有的类的基类,所以wait方法和notify方法需要定义在Object这个类中
* 3、sleep方法和wait方法的区别?
* a、sleep方法必须传入参数,参数就是时间,时间到了自动醒来,
* wait方法可以传入参数也可以不传入参数,传入参数就是在参数的时间结束后等待,不传入参数就是直接等待
* b、sleep方法在同步函数或同步代码块中,不释放锁,睡着了也抱着锁睡 wait方法在同步函数或者同步代码块中,释放锁
*/
class Printer2 {
private int flag = 1;
public void print1() throws InterruptedException {
synchronized (this) {
while (flag != 1) {
this.wait(); // 当前线程等待
}
System.out.print("黑");
System.out.print("马");
System.out.print("程");
System.out.print("序");
System.out.print("员");
System.out.print("\r\n");
flag = 2;
// this.notify(); //随机唤醒单个等待的线程
this.notifyAll();
}
}
public void print2() throws InterruptedException {
synchronized (this) {
while (flag != 2) {
this.wait(); // 线程2在此等待
}
System.out.print("传");
System.out.print("智");
System.out.print("播");
System.out.print("客");
System.out.print("\r\n");
flag = 3;
// this.notify();
this.notifyAll();
}
}
public void print3() throws InterruptedException {
synchronized (this) {
while (flag != 3) {
this.wait(); // 线程3在此等待,if语句是在哪里等待,就在哪里起来
// while循环是循环判断,每次都会判断标记
}
System.out.print("i");
System.out.print("t");
System.out.print("h");
System.out.print("e");
System.out.print("i");
System.out.print("m");
System.out.print("a");
System.out.print("\r\n");
flag = 1;
// this.notify();
this.notifyAll();
}
}
}
JDK1.5新特性互斥锁(掌握)
同步
- 使用ReentrantLock类的lock()和unlock()方法进行同步
通信
- 使用ReentrantLock类的newCondition()方法可以获取Condition对象
- 需要等待的时候使用Condition的await()方法, 唤醒的时候用signal()方法
- 不同的线程使用不同的Condition, 这样就能区分唤醒的时候找哪个线程了
package com.heima.thread2;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;
public class Demo3_ReentrantLock {
public static void main(String[] args) {
final Printer3 p = new Printer3();
new Thread() {
public void run() {
while (true) {
try {
p.print1();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}.start();
new Thread() {
public void run() {
while (true) {
try {
p.print2();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}.start();
new Thread() {
public void run() {
while (true) {
try {
p.print3();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}.start();
}
}
class Printer3 {
private ReentrantLock r = new ReentrantLock();
private Condition c1 = r.newCondition();
private Condition c2 = r.newCondition();
private Condition c3 = r.newCondition();
private int flag = 1;
public void print1() throws InterruptedException {
r.lock(); // 获取锁
if (flag != 1) {
c1.await();
}
System.out.print("黑");
System.out.print("马");
System.out.print("程");
System.out.print("序");
System.out.print("员");
System.out.print("\r\n");
flag = 2;
// this.notify(); //随机唤醒单个等待的线程
c2.signal();
r.unlock(); // 释放锁
}
public void print2() throws InterruptedException {
r.lock();
if (flag != 2) {
c2.await();
}
System.out.print("传");
System.out.print("智");
System.out.print("播");
System.out.print("客");
System.out.print("\r\n");
flag = 3;
// this.notify();
c3.signal();
r.unlock();
}
public void print3() throws InterruptedException {
r.lock();
if (flag != 3) {
c3.await();
}
System.out.print("i");
System.out.print("t");
System.out.print("h");
System.out.print("e");
System.out.print("i");
System.out.print("m");
System.out.print("a");
System.out.print("\r\n");
flag = 1;
c1.signal();
r.unlock();
}
}
线程组的概述和使用(了解)
线程组的概述
Java中使用ThreadGroup来表示线程组,它可以对一批线程进行分类管理,Java允许程序直接对线程组进行控制
默认情况下,所有的线程都属于主线程组。
public final ThreadGroup getThreadGroup()//通过线程对象获取他所属于的组
public final String getName()//通过线程组对象获取他组的名字
我们也可以给线程设置分组
1,ThreadGroup(String name) 创建线程组对象并给其赋值名字
2,创建线程对象
3,Thread(ThreadGroup?group, Runnable?target, String?name)
4,设置整组的优先级或者守护线程
案例演示
- 自己设定线程组
package com.heima.thread2;
public class Demo4_ThreadGroup {
public static void main(String[] args) {
// demo1();
ThreadGroup tg = new ThreadGroup("我是一个新的线程组");// 创建新的线程组
MyRunnable mr = new MyRunnable();// 创建Runnable的子类对象
Thread t1 = new Thread(tg, mr, "张三");// 将线程t1放在组中
Thread t2 = new Thread(tg, mr, "李四");// 将线程t2放在组中
System.out.println(t1.getThreadGroup().getName());// 获取组名
System.out.println(t2.getThreadGroup().getName());
}
private static void demo1() {
MyRunnable mr = new MyRunnable();
Thread t1 = new Thread(mr, "张三");
Thread t2 = new Thread(mr, "李四");
ThreadGroup tg1 = t1.getThreadGroup();
ThreadGroup tg2 = t2.getThreadGroup();
System.out.println(tg1.getName());// 默认的是主线程
System.out.println(tg2.getName());// 默认的是主线程
}
}
class MyRunnable implements Runnable {
public void run() {
for (int i = 0; i < 1000; i++) {
System.out.println(Thread.currentThread().getName() + "..." + i);
}
}
}
线程的五种状态(掌握)
- 看图说话
新建、就绪、运行、阻塞、死亡
线程池的概述和使用(了解)
线程池概述
程序启动一个新线程成本是比较高的,因为它涉及到要与操作系统进行交互。而使用线程池可以很好的提高性能,尤其是当程序中要创建大量生存期很短的线程时,更应该考虑使用线程池。线程池里的每一个线程代码结束后,并不会死亡,而是再次回到线程池中成为空闲状态,等待下一个对象来使用。在JDK5之前,我们必须手动实现自己的线程池,从JDK5开始,Java内置支持线程池。
内置线程池的使用概述
JDK5新增了一个Executors工厂类来产生线程池,有如下几个方法
* public static ExecutorService newFixedThreadPool(int nThreads)
创建一个可重用固定线程数的线程池,以共享的无界队列方式来运行这些线程
* public static ExecutorService newSingleThreadExecutor()
创建一个使用单个 worker 线程的 Executor,以无界队列方式来运行该线程。
* 这些方法的返回值是ExecutorService对象,该对象表示一个线程池,可以执行Runnable对象或者Callable对象代表的线程。它提供了如下方法
* Future<?> submit(Runnable task)
* <T> Future<T> submit(Callable<T> task)
使用步骤
- 创建线程池对象
- 创建Runnable实例
- 提交Runnable实例
- 关闭线程池
案例演示
package com.heima.thread2;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class Demo5_Executors {
public static void main(String[] args) {
ExecutorService pool = Executors.newFixedThreadPool(2);// 创建线程池
pool.submit(new MyRunnable());// 将线程放进池子里并执行
pool.submit(new MyRunnable());
pool.shutdown();// 关闭线程池
}
}
多线程程序实现的方式3(了解)
- 提交的是Callable
package com.heima.thread2;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
public class Demo6_Callable {
public static void main(String[] args) throws InterruptedException, ExecutionException {
ExecutorService pool = Executors.newFixedThreadPool(2);// 创建线程池
Future<Integer> f1 = pool.submit(new MyCallable(100));
Future<Integer> f2 = pool.submit(new MyCallable(50));
System.out.println(f1.get());// 5050
System.out.println(f2.get());// 1275
pool.shutdown();// 关闭线程池
}
}
class MyCallable implements Callable<Integer> {
private int num;
public MyCallable(int num) {
this.num = num;
}
@Override
public Integer call() throws Exception {
int sum = 0;
for (int i = 1; i <= num; i++) {
sum += i;
}
return sum;
}
}
多线程程序实现的方式3的好处和弊端
好处
- 可以有返回值
- 可以抛出异常
弊端
- 代码比较复杂,所以一般不用