(1)多进程
进程:正在执行的应用程序。
正在运行的程序,是系统进行资源分配和调用的独立单位。
每一个进程都有它自己的内存空间和系统资源。
多进程的意义?
单进程计算机只能做一件事情。
而我们现在的计算机都可以一边玩游戏(游戏进程),一边听音乐(音乐进程),
所以我们常见的操作系统都是多进程操作系统。比如:Windows,Mac和Linux等,能在同一个时间段内执行多个任务。
对于单核计算机来讲,游戏进程和音乐进程是同时运行的吗? 不是。
因为CPU在某个时间点上只能做一件事情,计算机是在游戏进程和音乐进程间做着频繁切换,
且切换速度很快,所以,我们感觉游戏和音乐在同时进行,其实并不是同时执行的。
多进程的作用不是提高执行速度,而是提高CPU的使用率。
(2)多线程
线程:进程的执行路径,执行单元,依赖于进程存在的。
在一个进程内部又可以执行多个任务,而这每一个任务我们就可以看成是一个线程。
线程是进程中的单个顺序控制流,是一条执行路径,是程序使用CPU的基本单位。
一个进程如果只有一条执行路径,则称为单线程程序。
一个进程如果有多条执行路径,则称为多线程程序。
多线程的意义?
多线程的作用不是提高执行速度,而是为了提高应用程序的使用率。
而多线程却给了我们一个错觉:让我们认为多个线程是并发执行的。其实不是。
因为多个线程共享同一个进程的资源(堆内存和方法区),但是栈内存是独立的,
一个线程一个栈。所以他们仍然是在抢CPU的资源执行。
一个时间点上只有能有一个线程执行。而且谁抢到,这个不一定,所以,造成了线程运行的随机性。
随机性原理:
因为多个线程不断去抢CPU的资源,CPU就在这多个线程间进行快速的切换,造成了随机性。
(3)并行和并发
并行:逻辑上同时发生,指在某一个时间内同时运行多个程序
并发:物理上同时发生,指在某一个时间点同时运行多个程序
(4)多线程的实现方案
A:继承Thread类
步骤:
a:自定义类MyThread继承自Thread类
b:重写run()方法
因为run()方法封装的代码才是被线程执行的代码。
c:创建子类对象
d:启动线程
启动线程使用的是那个方法呢?
start():启动线程,并自动调用run()方法。
Thread类的基本获取和设置方法
public final String getName()
public final void setName(String name)
通过构造方法也可以给线程起名字
如果没有设置名称,会有一个默认名称。Thread-编号
如何获取main方法所在的线程名称呢?
public static Thread currentThread()
这样就可以获取任意方法所在的线程名称
B:实现Runnable接口
步骤:
a:定义类MyRunnable实现接口Runnable
b:重写run()方法
c:创建MyRunnable的对象
d:创建Thread类的对象,并把C步骤的对象作为构造参数传递
e:启动线程
实现接口方式的好处:
可以避免由于Java单继承带来的局限性。
适合多个相同程序的代码去处理同一个资源的情况,把线程同程序的代码,
数据有效分离,较好的体现了面向对象的设计思想。
(5)常见的几个小问题
A:为什么要重写run()方法
B:启动线程使用的是哪个方法
C:start()和run()方法的区别
start:启动线程,并自动调用run()方法
run:直接调用,仅仅是普通方法的调用
D:一个线程能不能启动多次? 不能
E:有了继承Thread类实现,为什么还要有实现接口的实现
F:生命周期
(6)线程的调度
假如我们的计算机只有一个 CPU,那么CPU在某一个时刻只能执行一条指令,
线程只有得到CPU时间片,也就是使用权,才可以执行指令。
线程调度:
A:分时调度模型:所有线程轮流使用 CPU 的使用权,平均分配每个线程占用 CPU 的时间片
B:抢占式调度模型:优先让优先级高的线程使用 CPU,如果线程的优先级相同,那么会随机选择一个,优先级高的线程获取的 CPU 时间片相对多一些。
Java使用的是抢占式调度模型。
获取和设置线程的优先级:
public final int getPriority()
public final void setPriority(int newPriority)
默认优先级是5
优先级范围是1-10
(7)线程的控制
A:线程休眠
public static void sleep(long millis)
B:线程加入
public final void join()
C:线程礼让
public static void yield()
D:守护线程
当正在运行的线程都是守护线程时,Java 虚拟机退出。
public final void setDaemon(boolean on)
E:中断线程
public final void stop()
public void interrupt()
(8)多线程的生命周期图(见下)
(9)通过多线程模拟电影院卖票
A:继承Thread类
B:实现Runnable接口
(10)通过多线程模拟电影院卖票(加入延迟)
某电影院目前正在上映贺岁大片,共有100张票,而它有3个售票窗口售票,请设计一个程序模拟该电影院售票。
A:相同的票卖多次
CPU的一次执行必须是原子性操作
B:出现了负数的票
线程的随机性和延迟
(11)线程安全问题是如何产生的呢?
A:多线程环境
B:有共享数据
C:多条语句操作共享数据
(12)解决方案:
基本思想:让程序没有安全问题的环境。
实现:把多个语句操作共享数据的代码给锁起来,让任意时刻只能有一个线程执行即可。
A:同步代码块
格式:
synchronized(对象) {
需要被同步的代码;
}
对象可以是任意对象
同步可以解决安全问题的根本原因就在那个对象上,该对象如同锁的功能。
B:同步方法: 就是把同步关键字加到方法上
非静态 对象是this
静态 对象是当前类的字节码文件对象
同步的前提
多个线程
多个线程使用的是同一个锁对象
同步的好处
同步的出现解决了多线程的安全问题。
同步的弊端
当线程相当多时,因为每个线程都会去判断同步上的锁,很耗费资源,无形中会降低程序的运行效率。
如果锁对象是this,就可以考虑使用同步方法。
否则能使用同步代码块的尽量使用同步代码块。
(13)查看源码,回顾前面的线程安全问题
StringBuffer/StringBuilder
Vector
Hashtable
以及Collections中的让集合同步功能。
JDK5中Lock锁的使用
虽然我们可以理解同步代码块和同步方法的锁对象问题,
但是我们并没有直接看到在哪里加上了锁,在哪里释放了锁,
为了更清晰的表达如何加锁和释放锁,JDK5以后提供了一个新的锁对象Lock
Lock
void lock()
void unlock()
ReentrantLock
线程的生命周期图
多线程两种方式和常见小问题
线程的状态转换图
代码演示,以下代码按学习顺序来排列的
多线程初识
class Test{
public static void main(String[] args){
MyThread mt = new MyThread();
mt.run();
mt.run();
System.out.println("===================");
//2个 run()依次执行
MyThread mt1 = new MyThread();
MyThread mt2 = new MyThread();
mt1.run();
mt2.run();
System.out.println("===================");
//2个 MyThread()依次执行
MyThread mt3 = new MyThread();
MyThread mt4 = new MyThread();
mt3.start();
mt4.start();
System.out.println("===================");
//2个 MyThread()伪同步执行
}
}
class MyThread extends Thread{
@Override
public void run(){
for(int i=0; i<10; i++){
System.out.println(getName()+"---hello"+i);
}
}
}
多线程线程名:无参+setXxx 或 带参
class Test{
public static void main(String[] args){
// 无参+setXxx()
MyThread mt1 = new MyThread();
MyThread mt2 = new MyThread();
mt1.setName("张三");
mt2.setName("李四");
mt1.start();
mt2.start();
System.out.println("===================");
// 带参
MyThread mt3 = new MyThread("王五");
MyThread mt4 = new MyThread("赵六");
mt3.start();
mt4.start();
System.out.println(Thread.currentThread().getName() + "---AAA");
}
}
class MyThread extends Thread{
public MyThread() {
}
public MyThread(String name) {
super(name);
}
@Override
public void run(){
for(int i=0; i<10; i++){
System.out.println(getName()+"---hello"+i);
}
}
}
线程的优先级
class Test{
public static void main(String[] args){
ThreadPriority tp1 = new ThreadPriority();
ThreadPriority tp2 = new ThreadPriority();
ThreadPriority tp3 = new ThreadPriority();
tp1.setName("tp1");
tp2.setName("tp2");
tp3.setName("tp3");
//获取默认优先级
System.out.println(tp1.getPriority());
System.out.println(tp2.getPriority());
System.out.println(tp3.getPriority());
// 设置线程优先级
// IllegalArgumentException
// tp1.setPriority(1000);
tp1.setPriority(1);
tp2.setPriority(5);
tp3.setPriority(10);
System.out.println(tp1.getPriority());
System.out.println(tp2.getPriority());
System.out.println(tp3.getPriority());
// 启动线程
tp1.start();
tp2.start();
tp3.start();
}
}
守护线程
class Test{
public static void main(String[] args){
Thread.currentThread().setName("刘备");
ThreadDaemon td1 = new ThreadDaemon();
ThreadDaemon td2 = new ThreadDaemon();
td1.setName("关羽");
td2.setName("张飞");
// 设置守护线程:当正在运行的线程都是守护线程时,JVM退出。
td1.setDaemon(true);
td2.setDaemon(true);
td1.start();
td2.start();
for (int x = 0; x < 5; x++) {
System.out.println(Thread.currentThread().getName() + ":" + x);
}
}
}
class ThreadDaemon extends Thread{
@Override
public void run(){
for(int i=0; i<10; i++){
System.out.println(getName()+"---hello"+i);
}
}
}
线程加入
class Test{
public static void main(String[] args){
ThreadJoin tj1 = new ThreadJoin();
ThreadJoin tj2 = new ThreadJoin();
ThreadJoin tj3 = new ThreadJoin();
tj1.setName("李渊");
tj2.setName("李世民");
tj3.setName("李元霸");
tj1.start();
try {
tj1.join();//等待该线程终止
} catch (InterruptedException e) {
e.printStackTrace();
}
tj2.start();
tj3.start();
}
}
class ThreadJoin extends Thread {
@Override
public void run() {
for (int x = 0; x < 10; x++) {
System.out.println(getName() + ":" + x);
}
}
}
中断线程
import java.text.SimpleDateFormat;
import java.util.Date;
class Test{
public static void main(String[] args){
ThreadKill tk = new ThreadKill();
tk.start();
try {
Thread.sleep(3000);
//tk.stop(); //直接死
tk.interrupt(); //死后还可以写遗嘱
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
class ThreadKill extends Thread {
@Override
public void run() {
System.out.println("开始执行:"+ new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()));
try {
Thread.sleep(10000);
} catch (InterruptedException e) {
// e.printStackTrace();
System.out.println("我被杀死了");
}
System.out.println("结束执行:"+ new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()));
}
}
线程休眠
import java.text.SimpleDateFormat;
import java.util.Date;
public class Test {
public static void main(String[] args) {
ThreadSleep ts1 = new ThreadSleep();
ThreadSleep ts2 = new ThreadSleep();
ThreadSleep ts3 = new ThreadSleep();
ts1.setName("和珅");
ts2.setName("秦桧");
ts3.setName("高俅");
ts1.start();
ts2.start();
ts3.start();
}
}
class ThreadSleep extends Thread {
@Override
public void run() {
for (int x = 0; x < 10; x++) {
System.out.println(getName()+ ":"+ x+ "---"+ new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()));
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
礼让线程
public class Test {
public static void main(String[] args) {
ThreadYield ty1 = new ThreadYield();
ThreadYield ty2 = new ThreadYield();
ty1.setName("ty1");
ty2.setName("ty2");
ty1.start();
ty2.start();
}
}
class ThreadYield extends Thread {
@Override
public void run() {
for (int x = 0; x < 10; x++) {
System.out.println(getName() + ":" + x);
Thread.yield();//礼让线程,暂停当前正在执行的线程对象,并执行其他线程
}
}
}
线程实现方案二:实现Runnable接口
/*
* 实现Runnable接口的步骤:
*
* A:定义类MyRunnable实现接口Runnable
* B:重写run()方法
* C:创建MyRunnable的对象
* D:创建Thread类的对象,并把C步骤的对象作为构造参数传递
* E:启动线程
*
* 有了继承Thread类的方式,为什么还要有实现Runnable接口的方式?
* 原因是因为类是单继承。
*/
public class Test {
public static void main(String[] args) {
// 创建MyRunnable的对象
MyRunnable my = new MyRunnable();
// 创建Thread类的对象,并把C步骤的对象作为构造参数传递
// Thread(Runnable target)
// Thread(Runnable target, String name)
Thread t1 = new Thread(my, "t1");
Thread t2 = new Thread(my, "t2");
t1.start();
t2.start();
}
}
class MyRunnable implements Runnable {
@Override
public void run() {
for (int x = 0; x < 10; x++) {
System.out.println(Thread.currentThread().getName() + ":" + x);
}
}
}
卖票问题实现一:继承Thread
public class Test {
public static void main(String[] args) {
MovieTicket mt1 = new MovieTicket();
MovieTicket mt2 = new MovieTicket();
MovieTicket mt3 = new MovieTicket();
mt1.setName("窗口1");
mt2.setName("窗口2");
mt3.setName("窗口3");
mt1.start();
mt2.start();
mt3.start();
}
}
class MovieTicket extends Thread {
private static int tickets = 100;
@Override
public void run() {
while (true) {
if (tickets > 0) {
System.out.println(getName() + "正在出售第" + (tickets--) + "张票");
}
}
}
}
卖票问题实现二:实现Runnable 接口
public class Test {
public static void main(String[] args) {
MovieTicket mt = new MovieTicket();
Thread t1 = new Thread(mt, "窗口1");
Thread t2 = new Thread(mt, "窗口2");
Thread t3 = new Thread(mt, "窗口3");
t1.start();
t2.start();
t3.start();
}
}
class MovieTicket2 implements Runnable {
private int tickets = 100;
@Override
public void run() {
while (true) {
if (tickets > 0) {
System.out.println(Thread.currentThread().getName() + "正在出售第"+ (tickets--) + "张票");
}
}
}
}
考虑延时问题,加入线程睡眠,却发现以下代码出现bug
bug:
A:相同的票出现了多次
CPU的一次操作必须是原子性的
B:还出现了负数票的情况
随机性和延迟导致的
public class Test {
public static void main(String[] args) {
MovieTicket mt = new MovieTicket();
Thread t1 = new Thread(mt, "窗口1");
Thread t2 = new Thread(mt, "窗口2");
Thread t3 = new Thread(mt, "窗口3");
t1.start();
t2.start();
t3.start();
}
}
class MovieTicket implements Runnable {
private int tickets = 100;
@Override
public void run() {
while (true) {
if (tickets > 0) {
try {
Thread.sleep(100);// t1进来了,t2进来了,t3进来了
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "正在出售第"+ (tickets--) + "张票");
}
}
}
}
解决:
方式一:同步代码块
方式二:同步方法
方式一:同步代码块
public class Test {
public static void main(String[] args) {
MovieTicket mt = new MovieTicket();
Thread t1 = new Thread(mt, "窗口1");
Thread t2 = new Thread(mt, "窗口2");
Thread t3 = new Thread(mt, "窗口3");
t1.start();
t2.start();
t3.start();
}
}
class MovieTicket implements Runnable {
private int tickets = 100;
@Override
public void run() {
while (true) {
// t1,t2,t3
// t1过来了,看到了同步代码块的锁标记,绿色标记(火车上厕所,过马路的红绿灯)
// t2,t3都只能在这里等待
synchronized (this) {
// t1就进来了,立马修改标记为红色标记
if (tickets > 0) {
// 更符合现实情况
try {
Thread.sleep(100); // t1休息会
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+ "正在出售第" + (tickets--) + "张票");
}
}
// t1出来了,立马修改标记为绿色标记
}
}
}
方式二:同步方法
public class Test {
public static void main(String[] args) {
MovieTicket mt = new MovieTicket();
Thread t1 = new Thread(mt, "窗口1");
Thread t2 = new Thread(mt, "窗口2");
Thread t3 = new Thread(mt, "窗口3");
t1.start();
t2.start();
t3.start();
}
}
class MovieTicket implements Runnable {
private static int tickets = 100;
private Object obj = new Object();
private int x = 0;
@Override
public void run() {
while (true) {
if (x % 2 == 0) {
synchronized (MovieTicket.class) {
if (tickets > 0) {
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+ "正在出售第" + (tickets--) + "张票");
}
}
} else {
sellTicket();
}
x++;
}
}
private static synchronized void sellTicket() {
if (tickets > 0) {
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "正在出售第"+ (tickets--) + "张票");
}
}
}
Lock锁
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
/*
* 为了更清楚的让我们知道是如何加锁和释放锁的,JDK5以后就提供了一个接口:Lock锁。
* Lock
* public void lock():加锁
* public void unlock():释放锁
* 实现类对象
* public ReentrantLock()
*/
public class Test {
public static void main(String[] args) {
MovieTicket mt = new MovieTicket();
Thread t1 = new Thread(mt, "窗口1");
Thread t2 = new Thread(mt, "窗口2");
Thread t3 = new Thread(mt, "窗口3");
t1.start();
t2.start();
t3.start();
}
}
class MovieTicket implements Runnable {
private int tickets = 100;
private Object obj = new Object();
// 造锁
// private ReentrantLock lock = new ReentrantLock();
private Lock lock = new ReentrantLock();
@Override
public void run() {
while (true) {
try {
lock.lock();// 加锁
if (tickets > 0) {
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+ "正在出售第" + (tickets--) + "张票");
}
} finally {
lock.unlock();// 释放锁
}
}
}
}
同步弊端
效率低
如果出现了同步嵌套,就容易产生死锁问题
死锁问题
是指两个或者两个以上的线程在执行的过程中,因争夺资源产生的一种互相等待现象
同步代码块的嵌套
class Test {
public static void main(String[] args) {
//死锁:是指两个或者两个以上的线程在执行的过程中,因争夺资源产生的一种互相等待现象
DieLock d1 = new DieLock(true);
DieLock d2 = new DieLock(false);
d1.start();
d2.start();
}
}
class MyLock {
public static final Object objA = new Object();
public static final Object objB = new Object();
}
class DieLock extends Thread {
private boolean flag;
public DieLock(boolean flag) {
this.flag = flag;
}
@Override
public void run() {
if (flag) {
synchronized (MyLock.objA) {
System.out.println("if objA"); // CPU的执行权没有了
synchronized (MyLock.objB) {
System.out.println("if objB");
}
}
} else {
synchronized (MyLock.objB) {
System.out.println("else objB");
synchronized (MyLock.objA) {
System.out.println("else objA");
}
}
}
}
}
针对同一个资源的操作有不同种类的线程
举例:卖票有进的,也有出的。
通过设置线程(生产者)和获取线程(消费者)针对同一个学生对象进行操作
线程间通信的代码改进
A:通过等待唤醒机制实现数据依次出现
wait() 让线程处于等待
notify() 唤醒单个线程
notifyAll() 唤醒所有线程
B:把同步代码块改进为同步方法实现
public class Test {
public static void main(String[] args) {
Student s = new Student();
SetThread st = new SetThread(s);
GetThread gt = new GetThread(s);
Thread t1 = new Thread(st);
Thread t2 = new Thread(gt);
t1.start();
t2.start();
}
}
class SetThread implements Runnable {
private Student s;
public SetThread(Student s) {
this.s = s;
}
@Override
public void run() {
s.name = "林青霞";
s.age = 28;
}
}
class GetThread implements Runnable {
private Student s;
public GetThread(Student s) {
this.s = s;
}
@Override
public void run() {
System.out.println(s.name + "---" + s.age);
}
}
class Student {
String name;
int age;
}
加2个锁
public class Test {
public static void main(String[] args) {
Student s = new Student();
SetThread st = new SetThread(s);
GetThread gt = new GetThread(s);
Thread t1 = new Thread(st);
Thread t2 = new Thread(gt);
t1.start();
t2.start();
}
}
class SetThread implements Runnable {
private Student s;
private int x = 0;
public SetThread(Student s) {
this.s = s;
}
@Override
public void run() {
while (true) {
synchronized (s) {
if (x % 2 == 0) {
s.name = "林青霞";。
s.age = 28;
} else {
s.name = "刘意";
s.age = 31;
}
x++;
}
}
}
}
class GetThread implements Runnable {
private Student s;
public GetThread(Student s) {
this.s = s;
}
@Override
public void run() {
while (true) {
synchronized (s) {
System.out.println(s.name + "---" + s.age);
}
}
}
}
class Student {
String name;
int age;
}
同步代码块 + 线程等待 & 唤醒线程
public class Test {
public static void main(String[] args) {
Student s = new Student();
SetThread st = new SetThread(s);
GetThread gt = new GetThread(s);
Thread t1 = new Thread(st);
Thread t2 = new Thread(gt);
t1.start();
t2.start();
}
}
class SetThread implements Runnable {
private Student s;
private int x = 0;
public SetThread(Student s) {
this.s = s;
}
@Override
public void run() {
while (true) {
synchronized (s) {
if (s.flag) {//表示有数据
try {
s.wait(); // t1就等待了
} catch (InterruptedException e) {
e.printStackTrace();
}
}
if (x % 2 == 0) {
s.name = "林青霞";
s.age = 28;
} else {
s.name = "刘意";
s.age = 31;
}
x++;
s.flag = true;
s.notify(); //唤醒等待的线程,并不代表该线程能够立即获取CPU的执行权
}
}
}
}
class GetThread implements Runnable {
private Student s;
public GetThread(Student s) {
this.s = s;
}
@Override
public void run() {
while (true) {
synchronized (s) {
if (!s.flag) {//如果没有数据,就等待
try {
s.wait(); //t2就等待了,释放了锁对象,从哪里跌倒从哪里爬起。
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println(s.name + "---" + s.age);
s.flag = false;
s.notify();//唤醒单个线程
}
}
}
}
class Student {
String name;
int age;
boolean flag = false; // 表示是否有数据
}
同步方法
public class Test {
public static void main(String[] args) {
Student s = new Student();
SetThread st = new SetThread(s);
GetThread gt = new GetThread(s);
Thread t1 = new Thread(st);
Thread t2 = new Thread(gt);
t1.start();
t2.start();
}
}
class SetThread implements Runnable {
private Student s;
private int x = 0;
public SetThread(Student s) {
this.s = s;
}
@Override
public void run() {
while (true) {
if (x % 2 == 0) {
s.set("林青霞", 28);
} else {
s.set("刘意", 31);
}
x++;
}
}
}
class GetThread implements Runnable {
private Student s;
public GetThread(Student s) {
this.s = s;
}
@Override
public void run() {
while (true) {
s.get();
}
}
}
class Student {
private String name;
private int age;
private boolean flag = false; // 表示是否有数据
public synchronized void set(String name, int age) {
if (this.flag) {
try {
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
this.name = name;
this.age = age;
this.flag = true;
this.notify();
}
public synchronized void get() {
if (!this.flag) {
try {
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println(this.name + "---" + this.age);
this.flag = false;
this.notify();
}
}
Java中使用ThreadGroup来表示线程组,它可以对一批线程进行分类管理,
Java允许程序直接对线程组进行控制。
默认情况下,所有的线程都属于主线程组。
public final ThreadGroup getThreadGroup()
我们也可以给线程设置分组
Thread(ThreadGroup group, Runnable target, String name)
/*
* 线程组:Java中使用ThreadGroup来表示线程组,它可以对一批线程进行分类管理,Java允许程序直接对线程组进行控制。
*
* 默认情况下,所有的线程都属于主线程组。
* public final ThreadGroup getThreadGroup():返回该线程所属的线程组。
* public final String getName() :返回此线程组的名称。
* Thread(ThreadGroup group, Runnable target, String name):设置线程组名称
* public final int getMaxPriority() :返回此线程组最高优先级
*/
public class Test {
public static void main(String[] args) {
// method1();
method2();
}
// 设置线程所属的线程组
private static void method2() {
// public ThreadGroup(String name)
ThreadGroup tg = new ThreadGroup("tg");
tg.setDaemon(true);
ThreadGroupRunnable tgr = new ThreadGroupRunnable();
Thread t1 = new Thread(tg, tgr, "t1");
Thread t2 = new Thread(tg, tgr, "t2");
System.out.println(t1.getThreadGroup().getName());
System.out.println(t2.getThreadGroup().getName());
System.out.println(Thread.currentThread().getThreadGroup().getName());// main
// 设置t1,t2为守护线程:JVM退出
t1.setDaemon(true);
t2.setDaemon(true);
//tg.stop();
System.out.println(tg.isDaemon());
System.out.println(tg.getMaxPriority());
System.out.println(tg.toString());
tg.setMaxPriority(8);
System.out.println(tg.getMaxPriority());
System.out.println(t1.getPriority());
System.out.println(t2.getPriority());
t1.start();
t2.start();
}
// 获取线程所在的线程组名称
private static void method1() {
ThreadGroupRunnable tgr = new ThreadGroupRunnable();
Thread t1 = new Thread(tgr, "t1");
Thread t2 = new Thread(tgr, "t2");
// public final ThreadGroup getThreadGroup()
ThreadGroup tg1 = t1.getThreadGroup();
ThreadGroup tg2 = t2.getThreadGroup();
String t1Name = tg1.getName();
String t2Name = tg2.getName();
System.out.println(t1Name); // main
System.out.println(t2Name); // main
System.out.println(Thread.currentThread().getThreadGroup().getName()); // main
t1.start();
t2.start();
}
}
class ThreadGroupRunnable implements Runnable {
@Override
public void run() {
for (int x = 0; x < 10; x++) {
System.out.println(Thread.currentThread().getName() + ":" + x);
}
}
}
程序启动一个新线程成本是比较高的,因为它涉及到要与操作系统进行交互。而使用线程池可以很好的提高性能,尤其是当程序中要创建大量生存期很短的线程时,更应该考虑使用线程池。
线程池里的每一个线程代码结束后,并不会死亡,而是再次回到线程池中成为空闲状态,等待下一个对象来使用。
在JDK5之前,我们必须手动实现自己的线程池,从JDK5开始,Java内置支持线程池
JDK5新增了一个Executors工厂类来产生线程池,有如下几个方法
public static ExecutorService newCachedThreadPool()
public static ExecutorService newFixedThreadPool(int nThreads)
public static ExecutorService newSingleThreadExecutor()
这些方法的返回值是ExecutorService对象,该对象表示一个线程池,可以执行Runnable对象或者Callable对象代表的线程。它提供了如下方法
Future> submit(Runnable task)
Future submit(Callable task)
案例演示
创建线程池对象
创建Runnable实例
提交Runnable实例
关闭线程池
public static ExecutorService newCachedThreadPool()
创建一个具有缓存功能的线程池
缓存:百度浏览过的信息再次访问
public static ExecutorService newFixedThreadPool(int nThreads)
创建一个可重用的,具有固定线程数的线程池
public static ExecutorService newSingleThreadExecutor()
创建一个只有单线程的线程池,相当于上个方法的参数是1
多线程程序实现方案3
实现Callable接口
步骤和线程池执行Runnable对象的差不多。
但是还可以更好玩一些,求和案例演示
好处:
可以有返回值
可以抛出异常
弊端:
代码比较复杂,所以一般不用
匿名内部类方式使用多线程
new Thread(){代码…}.start();
New Thread(new Runnable(){代码…}).start();
代码演示:
new Thread() {
public void run() {
for (int x = 0; x < 100; x++) {
System.out.println(getName() + "---" + x);
}
};
}.start();
new Thread(new Runnable() {
@Override
public void run() {
for (int x = 0; x < 100; x++) {
System.out.println(Thread.currentThread().getName() + "---"+ x);
}
}
}).start();
线程池
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
/*
* 线程池:线程池里的每一个线程代码结束后,并不会死亡,而是再次回到线程池中成为空闲状态,等待下一个对象来使用。
*
* 步骤:
* A:定义类MyRunnable实现Runnable接口
* B:创建MyRunnable对象
* C:创建线程池对象
* D:提交
* E:释放
*/
public class Test {
public static void main(String[] args) {
MyRunnable my = new MyRunnable();
// 创建线程池对象
// public static ExecutorService newFixedThreadPool(int nThreads)
ExecutorService pool = Executors.newFixedThreadPool(5);
// 提交代码
// Future> submit(Runnable task)
pool.submit(my);
pool.submit(my);
pool.submit(my);
pool.submit(my);
pool.submit(my);
// 释放
pool.shutdown();
}
}
class MyRunnable implements Runnable {
@Override
public void run() {
for (int x = 0; x < 10; x++) {
System.out.println(Thread.currentThread().getName() + ":" + x);
}
}
}
多线程实现方案三:实现 Callable接口
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Callable;
/*
* 线程池:线程池里的每一个线程代码结束后,并不会死亡,而是再次回到线程池中成为空闲状态,等待下一个对象来使用。
*
* 步骤:
* A:定义类MyCallable实现Callable接口
* B:创建MyCallable对象
* C:创建线程池对象
* D:提交
* E:释放
*/
public class Test {
public static void main(String[] args) {
MyCallable my = new MyCallable();
// 创建线程池对象
// public static ExecutorService newFixedThreadPool(int nThreads)
ExecutorService pool = Executors.newFixedThreadPool(5);
// 提交代码
// Future> submit(Runnable task)
pool.submit(my);
pool.submit(my);
pool.submit(my);
pool.submit(my);
pool.submit(my);
// 释放
pool.shutdown();
}
}
class MyCallable implements Callable {
@Override
public Object call() throws Exception {
for (int x = 0; x < 10; x++) {
System.out.println(Thread.currentThread().getName() + ":" + x);
}
return null;
}
}
求和案例:sum = 1+2+3+…+n
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;
/*
* 求和案例:sum = 1+2+3+...+n
*/
public class Test {
public static void main(String[] args) throws InterruptedException,ExecutionException {
// 创建线程池对象
ExecutorService pool = Executors.newFixedThreadPool(3);
// 提交数据
Future<Integer> f1 = pool.submit(new MyCallable(5));
Future<Integer> f2 = pool.submit(new MyCallable(10));
Future<Integer> f3 = pool.submit(new MyCallable(100));
Integer i1 = f1.get();
Integer i2 = f2.get();
Integer i3 = f3.get();
System.out.println(i1);
System.out.println(i2);
System.out.println(i3);
pool.shutdown();
}
}
class MyCallable implements Callable<Integer> {
private int number;
public MyCallable(int number) {
this.number = number;
}
@Override
public Integer call() throws Exception {
int sum = 0;
for (int x = 1; x <= number; x++) {
sum += x;
}
return sum;
}
}
匿名内部类的方式开启多线程程序
/*
* 匿名内部类的方式开启多线程程序。
*
* new 类名() {
* 重写方法
* };
*/
public class Test {
public static void main(String[] args) {
/*new Thread() {
@Override public void run() {
for (int x = 0; x < 10; x++) {
System.out.println("t1:" + x);
}
}
}.start();
new Thread() {
@Override public void run() {
for (int x = 0; x < 10; x++) {
System.out.println("t2:" + x);
}
}
}.start();*/
/*new Thread(new Runnable() {
@Override public void run() {
for (int x = 0; x < 10; x++) {
System.out.println("t3:" + x);
}
}
}).start();
new Thread(new Runnable() {
@Override public void run() {
for (int x = 0; x < 10; x++) {
System.out.println("t4:" + x);
}
}
}).start();*/
// 面试
new Thread(new Runnable() {
@Override
public void run() {
for (int x = 0; x < 10; x++) {
System.out.println("t5:" + x);
}
}
}) {
@Override
public void run() {
for (int x = 0; x < 10; x++) {
System.out.println("t6:" + x);
}
}
}.start();
}
}
定时器是一个应用十分广泛的线程工具,可用于调度多个定时任务以后台线程的方式执行。在Java中,可以通过Timer和TimerTask类来实现定义调度的功能
Timer
public Timer()
public void schedule(TimerTask task, long delay)
public void schedule(TimerTask task,long delay,long period)
TimerTask
public abstract void run()
public boolean cancel()
无论是TimerTask类还是Timer类,其cancel()方法都是为了清除任务队列中的任务。
虽然都是清除任务队列中的任务,却有一些不同:
TimerTask类中的cancel()方法侧重的是将自身从任务队列中清除,其他任务不受影响,
而Timer类中的cancel()方法则是将任务队列中全部的任务清空。
开发中Quartz是一个完全由java编写的开源调度框架。
1:演示3秒后执行某个动作,
2:演示3秒后执行某个动作,然后每隔2秒执行某个动作
3:可以把任务结束掉
import java.util.Timer;
import java.util.TimerTask;
/*
* 定义任务由两个类来一起完成:
* Timer,TimerTask
*
* Timer:
* public Timer()创建一个新计时器。
*/
public class Test {
public static void main(String[] args) {
// 创建定时器
final Timer t = new Timer();
// public void schedule(TimerTask task,long delay):在delay毫秒后完成task的任务
// t.schedule(new MyTask(t), 3000);
// 匿名内部类实现
t.schedule(new TimerTask() {
@Override
public void run() {
System.out.println("炸弹爆炸了,duang");
t.cancel();//清空队列中全部任务
}
}, 3000);
}
}
class MyTask extends TimerTask {
private Timer t;
public MyTask(Timer t) {
this.t = t;
}
@Override
public void run() {
System.out.println("炸弹爆炸了");
t.cancel();
}
}
连环雷 和 定时雷
/*
* 炸弹要连续炸
*/
public class Test {
public static void main(String[] args) throws ParseException {
Timer t = new Timer();
// 启动任务
t.schedule(new TimerTask() {
@Override
public void run() {
System.out.println("要炸了,快跑");
}
}, 2000);
//public void schedule(TimerTask task,long delay,long period):第一次是delay后启动,以后每次是period启动
t.schedule(new TimerTask() {
@Override
public void run() {
System.out.println("连环雷,炸死你");
}
}, 3000, 1000);
// public void schedule(TimerTask task,Date time):在time时间执行一次
// public void schedule(TimerTask task,Date time,long period):在time时间开始第一次执行,以后每次period再启动
String s = "2020-11-5 11:07:00";
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
Date d = sdf.parse(s);
t.schedule(new TimerTask() {
@Override
public void run() {
System.out.println("炸死你");
}
}, d,1000);
}
}
class MyTask extends TimerTask {
private Timer t;
public MyTask(Timer t) {
this.t = t;
}
@Override
public void run() {
System.out.println("炸弹爆炸了");
t.cancel();
}
}
多线程面试题
(1)多线程有几种实现方案,分别是哪几种?
(2)同步有几种方式,分别是什么?
(3)启动一个线程是run()还是start()?它们的区别?
(4)sleep()和wait()方法的区别
(5)为什么wait(),notify(),notifyAll()等方法都定义在Object类中
(6)线程的生命周期图
面试题答案
(1)多线程有几种实现方案,分别是哪几种?
答案:3种,但一般说2种常用的
- 继承Thread类
- 实现Runnable接口
- 实现Callable接口,代码复杂,一般不使用
- 匿名内部类也可以实现多线程
(2)同步有几种方式,分别是什么?
答案:2种
- 同步代码块
- 同步方法
(3)启动一个线程是run()还是start()?它们的区别?
答案:启动线程用 start();
区别:
run(): 封装了被线程执行的代码,直接调用仅仅是普通方法的调用
start(): 启动线程,并由JVM自动调用run()方法
注:start()方法被用来启动新创建的线程,而且start()内部调用了run()方法,这和直接调用run()方法的效果不一样。
当你调用run()方法的时候,只会是在原来的线程中调用,没有新的线程启动,start()方法才会启动新线程。
(4)sleep()和wait()方法的区别
答案:
sleep(): 必须指时间; 不释放锁。
wait(): 可以不指定时间,也可以指定时间; 释放锁
(5)为什么wait(),notify(),notifyAll()等方法都定义在Object类中
答案:
- 这些方法存在与同步中。
- 使用这些方法时必须要标识所属的同步的锁。
- 锁可以是任意对象,所以任意对象调用的方法一定定义Object类中。
(6)线程的生命周期图
- 新建(new):处于该状态的时间很短暂。已被分配了必须的系统资源,并执行了初始化。表示有资格获得CPU时间。调度器可以把该线程变为runnable或者blocked状态
- 就绪(Runnable):这种状态下只要调度器把时间片分配给线程,线程就能运行。处在这种状态就是可运行可不运行的状态
- 阻塞(Bolocked):线程能够运行,但有个条件阻止它的运行。当线程处于阻塞状态时,调度器将会忽略线程,不会分配给线程任何CPU时间(例如sleep)。只有重新进入了就绪状态,才有可能执行操作。
- 死亡(Dead):处于死亡状态的线程讲不再是可调度的,并且再也不会得到CPU时间。任务死亡的通常方式是从run()方法返回。
一个任务进入阻塞状态,可能有如下原因:
- sleep
- wait(),知道线程得到了notify()或者notifyAll()消息,线程才会进入就绪状态。
- 任务在等待某个输入/输出完成
- 线程在试图在某个对象上调用其同步控制方法,但是对象锁不可用,因为另一个任务已经获取了这个锁。