线程的状态
新建状态(New)、就绪状态(Runnable)、运行状态(Running)、阻塞状态(Blocked、Waiting、Timed_Waiting)、死亡状态(Terminated)。
线程的生命周期
新建状态 –> 就绪状态 :调用线程的start()方法。
就绪状态->运行状态 :JVM按照线程调度策略。
运行状态->阻塞状态 :等待事件。
阻塞状态->就绪状态 :唤醒。
运行状态->死亡状态 :线程结束。
等待唤醒机制
什么是等待唤醒机制?
在一个线程进行了规定操作后,就进入等待状态(wait()), 等待其他线程执行完他们的指定代码过后 再将其唤醒(notify());在有多个线程进行等待时, 如果需要,可以使用 notifyAll()来唤醒所有的等待线程。wait/notify 就是线程间的一种协作机制。
等待唤醒机制就是用于解决线程间通信的问题的,使用到的3个方法的含义如下:
调用wait和notify方法需要注意的细节
练习
package cn.anxincao.threadtest1;
public class LeftRight {
boolean flag = false;
class Left extends Thread{
//
@Override
public void run() {
for (int i = 0; i < 50; i++) {
synchronized (LeftRight.class) {
while (flag) {
try {
LeftRight.class.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.printf("%s\n", "左脚一步!");
flag = true;
LeftRight.class.notify();
}
}
}
}
class Right extends Thread{
@Override
public void run() {
for (int i = 0; i < 50; i++) {
synchronized (LeftRight.class){
while(!flag){ //flag为false时这段代码才会执行。
try{
LeftRight.class.wait();
}catch (InterruptedException e){
e.printStackTrace();
}
}
System.out.printf("%30s\n","右脚一步! ");
flag = false; //下一个循环就等待
LeftRight.class.notify(); // 唤醒同一个对象的另一个线程,
}
}
}
}
public static void main(String[] args) {
LeftRight lf = new LeftRight();
lf.new Left().start();
lf.new Right().start();
}
}
线程池
线程思想概述
如果并发的线程数量很多,并且每个线程都是执行一个时间很短的任务就结束了,这样频繁创建线程就会大大降低系统的效率,因为频繁创建线程和销毁线程需要时间。
在Java中可以通过线程池使得线程可以复用,就是执行完一个任务,并不被销毁,而是可以继续执行其他的任务。
线程池:JDK1.5之后提供的
java.util.concurrent.Executors:线程池的工厂类,用来生成线程池
Executors类中的静态方法:
static ExecutorService newFixedThreadPool(int nThreads)创建一个可重用固定线程数的线程池
参数:
int nThreads:创建线程池中包含的线程数量
返回值:
ExecutorService接口,返回的是ExecutorService接口的实现类对象,我们可以使用ExecutorService接口接收(面向接口编程)
java.util.concurrent.Executorservice:线程池接口
用来从线程池中获取线程,调用start方法,执行线程任务
submit(Runnable tosk)提交一个Runnable任务用于执行
关闭/销毁线程池的方法
void shutdown()
线程池的使用步骤:
1.使用线程池的工厂类Executors里边提供的静态方法newFixedThreadPool生产一个指定线程数量的线程池
2.创建一个类,实现Runnable接口,重写run方法,设置线程任务
3.调用ExecutorService中的方法submit,传递线程任务(实现类),开启线程,执行run方法
4.调用ExecutorService中的方法shutdown销毁线程池(不建议执行)
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class Threadpool {
public static void main(String[] args) {
// 创建线程池对象
ExecutorService service = Executors.newFixedThreadPool(2);//包含2个线程对象
// 创建Runnable实例对象
Runnable r = new Runnable() {
@Override
public void run() {
System.out.println("我要一个教练");
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("教练来了: " + Thread.currentThread().getName());
System.out.println("教我游泳,交完后,教练回到了游泳池");
}
};
//自己创建线程对象的方式
// Thread t = new Thread(r);
// t.start(); ‐‐‐> 调用MyRunnable中的run()
// 从线程池中获取线程对象,然后调用MyRunnable中的run()
service.submit(r);
// 再获取个线程对象,调用MyRunnable中的run()
service.submit(r);
service.submit(r);
// 注意:submit方法调用结束后,程序并不终止,是因为线程池控制了线程的关闭。
// 将使用完的线程又归还到了线程池中
// 关闭线程池
service.shutdown();
}
}
Lambda表达式
在数学中,函数就是有输入量、输出量的一套计算方案,也就是“拿什么东西做什么事情”。相对而言,面向对象过分强调“必须通过对象的形式来做事情”,而函数式思想则尽量忽略面向对象的复杂语法一—强调做什么,而不是以什么形式做。
面向对象的思想:
做一件事情,找一个能解决这个事情的对象,调用对象的方法,完成事情.
函数式编程思想:
只要能获取到结果,谁去做的,怎么做的都不重要,重视的是结果,不重视过程。
箭头代表传递。本质是将run方法体内的代码传递给Thread类。
练习
public class test1 {
public static void main(String[] args) {
//使用匿名内部类的方式,实现多线程
new Thread(new Runnable() {
@Override
public void run() {
System.out.println(Thread.currentThread().getName()+"新线程创建了");
}
}).start();
//使用Lambda 表达式,实现多线程
new Thread(()->{
System.out.println(Thread.currentThread().getName()+"新线程创建了");
}).start();
}
}
匿名内部类的好处与弊端
一方面,匿名内部类可以帮我们省去实现类的定义;另一方面,匿名内部类的语法——确实太复杂了!
语义分析
仔细分析该代码中的语义,Runnable接口只有一个run方法的定义:
·public abstract void run();即制定了一种做事情的方案(其实就是一个函数):
·无参数:不需要任何条件即可执行该方案。
·无返回值:该方案不产生任何结果。
·代码块(方法体):该方案的具体执行步骤。
同样的语义体现在Lambda 语法中,要更加简单:
()-> System.out.println(“多线程任务执行!")
Lambda表达式的标准格式:
由三部分组成:
a.一些参数
b.一个箭头
c.一段代码
格式:
(参数列表)->{一些重写方法的代码};
解释说明格式:
():接口中抽象方法的参数列表,没有参数,就空着;有参数就写出参数,多个参数使用逗号分隔
->:传递的意思,把参数传递给方法体{}
{ }:重写接口的抽象方法的方法体
Lambda省略式
在Lambda标准格式的基础上,使用省略写法的规则为:
加粗样式1.小括号内参数的类型可以省略;
2.如果小括号内有且仅有一个参,则小括号可以省略;
3.如果大括号内有且仅有一个语句,则无论是否有返回值,都可以省略大括号、return关键字及语句分号。