Lambda表达式(函数式编程)
- 函数式接口:只含有唯一一个抽象方法的接口就是函数式接口。
- 对于函数式接口,可通过lamda表达式来创建该接口的对象。
/*
推导Lamda表达式
*/
public class TestLambda1 {
//3.静态内部类
static class Like2 implements ILike{
@Override
public void lambda() {
System.out.println("I like Lambda2");
}
}
public static void main(String[] args) {
ILike like=new Like();
like.lambda();
like=new Like2();
like.lambda();
//4.局部内部类
class Like3 implements ILike{
@Override
public void lambda() {
System.out.println("I like Lambda3");
}
}
like=new Like3();
like.lambda();
//匿名内部类,没有类的名称,必须借助接口或者父类
like=new ILike() {
@Override
public void lambda() {
System.out.println("I like Lambda4");
}
};
like.lambda();
//6.用lambda简化 比匿名内部类去掉了方法名和接口
like=()->{
System.out.println("I like Lambda5");
};
like.lambda();
}
}
//1.定义一个函数式接口
interface ILike{
void lambda();
}
//2.实现类
class Like implements ILike{
@Override
public void lambda() {
System.out.println("I like Lambda");
}
}
含参数的示例:
public class TestLambda2 {
public static void main(String[] args) {
//1.lambda表达式简化
ILove love=(int a)-> {
System.out.println("i love you-->"+a);
};
//简化1.去掉参数类型
love=(a)->{
System.out.println("i love you-->"+a);
};
//简化2.简化括号
love=a->{
System.out.println("i love you-->"+a);
};
//简化3:去掉花括号
love=a-> System.out.println("i love you1-->"+a);
//总结:
//lambda表达式只能有一行代码的情况下才能简化为一行,如果有多行,必须用花括号包裹
//前提是接口为函数式接口
//多个参数也可去掉参数类型,要去就都去掉,此时必须加小括号(a,b)
love.love(520);
}
}
interface ILove{
void love(int a);
}
五大状态
线程方法:
停止线程
- 1.线程自行停止
- 2.用标志位flag进行终止。当flag=false,终止线程运行
//测试stop
//1.建议线程正常停止-->利用次数,不建议死循环
//2.建议使用标志位-->设置一个标志位
//3.不要使用stop或者destroy等过时或不建议用的方法
public class TestStop implements Runnable{
//1.设置一个标志位
private boolean flag=true;
@Override
public void run() {
int i=0;
while (flag){
System.out.println("run^^"+i++);
}
}
//2.设置一个公开的方法停止线程,转换标志位
public void stop(){
this.flag=false;
}
public static void main(String[] args) {
TestStop testStop=new TestStop();
new Thread(testStop).start();
for (int i = 0; i < 1000; i++) {
System.out.println("main"+i);
if(i==900){
//调用stop方法切换标志位 让线程停止
testStop.stop();
System.out.println("stop!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
}
}
}
}
线程休眠
- sleep(时间)指定当前线程的阻塞毫秒数
- sleep存在异常InterruptedException
- sleep时间达到后线程进入就绪状态
- sleep可以模拟网络延时,倒计时等
- 每个对象都有一个锁,sleep不会释放锁
获取系统时间并不断显示
public class TestSleep2 {
public static void main(String[] args) throws InterruptedException {
//打印当前系统时间
Date startTime=new Date(System.currentTimeMillis());//获取系统当前时间
while (true){
try {
Thread.sleep(1000);
System.out.println(new SimpleDateFormat("HH:mm:ss").format(startTime));
startTime=new Date(System.currentTimeMillis());//更新当前时间
} catch (InterruptedException e) {
e.printStackTrace();
}
}}
倒计时(10到1)
public class TestSleep2 {
public static void main(String[] args) throws InterruptedException {
tenDown();//静态内部类可以直接调用
}
//模拟倒计时
static void tenDown() throws InterruptedException {
int num=10;
while (true){
Thread.sleep(1000);
System.out.println(num--);
if (num<=0){
break;
}
}
}
}
线程礼让yield
- 礼让线程:当前正执行的线程暂停,但不阻塞
- 线程从运行状态转为就绪状态
- 让CPU重新调度,但不一定成功
//测试礼让线程
//礼让不一定成功,看CPU心情
public class TestYield {
public static void main(String[] args) {
MyYield myYield=new MyYield();
new Thread(myYield,"a").start();
new Thread(myYield,"b").start();
}
}
class MyYield implements Runnable{
@Override
public void run() {
System.out.println(Thread.currentThread().getName()+"线程开始执行");
Thread.yield();//礼让
System.out.println(Thread.currentThread().getName()+"线程停止执行");
}
}
礼让结果随机,可能成功可能不成功:
成功:
不成功:
Join
Join合并线程,等此线程执行完成后,再执行其他线程,其他线程阻塞(类似于插队)。
//测试Join方法 想象成插队
public class TestJoin implements Runnable{
@Override
public void run() {
for (int i = 0; i < 1000; i++) {
System.out.println("线程vip来了"+i);
}
}
public static void main(String[] args) throws InterruptedException {
//启动我们的线程
TestJoin testJoin=new TestJoin();
Thread thread=new Thread(testJoin);//静态代理
//主线程
for (int i = 0; i < 1000; i++) {
if(i==200){
thread.start();
thread.join();//插队
}
System.out.println("main"+i);
}
}
}
观测线程状态
线程可以处于以下状态:
- NEW:尚未启动的线程
- RUNNABLE:在java虚拟机中执行的线程
- BLOCKED:被阻塞等待监视器锁定的线程
- WAITTING:正等待另一个线程执行特定动作的线程
- TIMED_WAITING:正等待另一个线程执行动作达到指定等待时间的线程
- TERMANATED:已退出的线程
//观测线程状态
public class TestState {
public static void main(String[] args) throws InterruptedException {
Thread thread=new Thread(()-> {
for (int i = 0; i < 5; i++) { //5s的休眠时间 处于TIMED_WAITING状态
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println("//");
});
//观察状态
Thread.State state=thread.getState();
System.out.println(state); //NEW
//观察启动后
thread.start(); //启动线程 此时 就绪状态
state= thread.getState();
System.out.println(state);//Run
while (state!=Thread.State.TERMINATED){//只要线程不终止,就一直输出状态
Thread.sleep(100);
state= thread.getState();//更新线程状态
System.out.println(state); //输出线程状态
}
}
}
输出结果:
- 注意:TERMANATED后的线程 不能再次start,寿命只有一次。
优先级Priority
- 线程优先级用数字表示,进入就绪状态的所有线程,按照优先级决定先调度哪个:
Thread.MIN_PRIORITY=1;
Thread.MAX_PRIORITY=10;
Thread.MORM_PRIORITY=5; 不设置的话,默认是5
//测试线程的优先级
public class TestPriority {
public static void main(String[] args) {
//主线程默认优先级
System.out.println(Thread.currentThread().getName()+"-->"+Thread.currentThread().getPriority());
MyPriority myPriority=new MyPriority();
Thread t1= new Thread(myPriority);
Thread t2= new Thread(myPriority);
Thread t3= new Thread(myPriority);
Thread t4= new Thread(myPriority);
//先设置优先级,再启动,才会生效
t1.start();
t2.setPriority(1);
t2.start();
t3.setPriority(4);
t3.start();
t4.setPriority(Thread.MAX_PRIORITY); //MAX_PRIORITY=10
t4.start();
}
}
class MyPriority implements Runnable{
@Override
public void run() {
System.out.println(Thread.currentThread().getName()+"-->"+Thread.currentThread().getPriority());
}
}
- 注意:
优先级低只意味着获得调度的概率低。
优先级高的不一定一直先执行。
守护线程
用户线程 | 守护线程 |
---|---|
虚拟机必须确保用户线程执行完 | 虚拟机不用等守护线程执行完(如垃圾回收) |
//测试守护线程
//上帝守护你
public class TestDaemon {
public static void main(String[] args) {
God god=new God();
You you=new You();
Thread thread=new Thread(god);
thread.setDaemon(true); //默认是false,表示是用户线程。正常的线程都是用户线程
thread.start();//上帝守护线程启动
new Thread(you).start(); //你 用户线程启动
}
}
//上帝
class God implements Runnable{
@Override
public void run() {
while (true){
System.out.println("上帝保佑着你");
}
}
}
//你
class You implements Runnable{
@Override
public void run() {
for (int i = 0; i < 36500; i++) {
System.out.println("你一生都开心");
}
System.out.println("=======================================byebye!world!=======================================");
}
}
结果:
- 上帝线程反应过来后,随着你线程的结束而结束了。