Lamda表达式、线程停止，休眠，礼让（yield）,join,优先级，守护（daemon）、同步、Lock、线程池

本文主要是介绍Lamda表达式、线程停止，休眠，礼让（yield）,join,优先级，守护（daemon）、同步、Lock、线程池，对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！

Lamda表达式

（1）Functional Interface（函数式接口）

（2）函数式接口定义：（即接口只有一个方法）

·任何接口，如果只包含唯一一个抽象方法，则是一个函数式接口

·对于函数式接口，可以通过Lamda表达式创建函数式接口的对象

范例：（外部类）

package proxy;
// 接口
interface Ilike{
    public void lambda();
}
// 1、外部类
class Like1 implements Ilike{
    @Override
    public void lambda() {
        System.out.println("外部类");
    }
}
public class StaticProxy{
    public static void main(String[] args) {
        Like1 like1=new Like1();  //外部类
        like1.lambda(); //外部类
    }
}

范例：（静态内部类）

package proxy;
// 接口
interface Ilike{
    public void lambda();
}
​
public class StaticProxy{
    // 2、静态内部类
    static class Like1 implements Ilike{
        @Override
        public void lambda() {
            System.out.println("静态内部类");
        }
    }
    public static void main(String[] args) {
        Like1 like1=new Like1();  //静态内部类
        like1.lambda();//静态内部类
    }
}

范例：（局部内部类）

package proxy;
// 接口
interface Ilike{
    public void lambda();
}
​
public class StaticProxy{
​
    public static void main(String[] args) {
        // 2、局部内部类
        class Like1 implements Ilike{
            @Override
            public void lambda() {
                System.out.println("局部内部类");
            }
        }
​
        Like1 like1=new Like1();  //局部内部类
        like1.lambda();//局部内部类
    }
}

范例：（匿名内部类）

package proxy;
// 接口
interface Ilike{
    public void lambda();
}
​
public class StaticProxy{
​
    public static void main(String[] args) {
​
        Ilike like1=new Ilike() {
            @Override
            public void lambda() {
                System.out.println("匿名内部类");
            }
        };
        like1.lambda();  //匿名内部类
    }
}

范例：（Lamda表达式）---无参

package proxy;
// 接口
interface Ilike{
    public void lambda();
}
public class StaticProxy{
    public static void main(String[] args) {
​
        Ilike like=()->{
                System.out.println("Lamda表达式");
        };
        like.lambda();  //Lamda表达式
    }
}

范例：（Lamda表达式）---有参

package proxy;
// 接口
interface Ilike{
    public void lambda(int a);
}
​
public class StaticProxy{
​
    public static void main(String[] args) {
​
        Ilike like=(int a)->{
            System.out.println("Lamda表达式"+a);
        };
        like.lambda(10);  //Lamda表达式 10
    }
}

线程停止

（1）建议线程正常停止----->利用次数

（2）建议使用标志位---->设置一个标志位（true/false）

（3）不要用stop或者destroy等过时或JDK不建议用的方法

线程方法

范例：（停止线程）

package collection;
​
public class Demo4 implements Runnable{
    private  boolean flag=true;
    @Override
    public void run() {
        while (flag) {
            System.out.println("输出");
        }
    }
​
    public void stop(){
        this.flag=false;
    }
    public static void main(String[] args) {
        Demo4 d4=new Demo4();
        new Thread(d4).start();
​
        for (int i = 0; i <50 ; i++) {
            System.out.println("main"+i +"   ");
            if(i==30){
                d4.stop();
                System.out.println("线程停止了");
            }
        }
    }
}

线程休眠

（1）sleep存在异常InterruptedException

（2）sleep可以模拟网络延时，倒计时等

（3）每个对象都有一个锁，sleep不会释放锁

范例：（模拟倒计时）
package collection;
import java.text.SimpleDateFormat;
import java.util.Date;
​
public class Demo5 {
    public static void main(String[] args) throws InterruptedException {
        Date date=new Date(System.currentTimeMillis());  
// 获取当前系统的时间
        while (true){
            Thread.sleep(1000);  // 延时1秒
            System.out.println(new SimpleDateFormat("HH:mm:ss").format(date));
            date=new Date(System.currentTimeMillis());  
//（重新获取） 更新当前系统的时间
        }
    }
}

线程礼让yield

（1）线程礼让，即让当前正在执行的线程暂停，但不阻塞

（2）将线程从运行状态转为就绪状态

（3）让cpu重新调度，礼让不一定成功，看cpu心情

package collection;
class MyYield implements Runnable{
​
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"开始");
        Thread.yield();  //礼让
        System.out.println(Thread.currentThread().getName()+"停止");
    }
}
​
public class Demo6 {
    public static void main(String[] args) {
        MyYield my=new MyYield();
​
        new Thread(my,"a").start();
        new Thread(my,"b").start();
/*
        不礼让，则开始-结束为一对出现
        a开始
        a停止
        b开始
        b停止
 */
/*
        礼让，则开始-结束不为一对出现（也可能一对出现，可能礼让不成功）
        a开始
        a停止
        b开始
        b停止
 */
    }
}

join

（1）join合并线程，待此线程执行完成后，再执行其他线程，其他线程阻塞（可以理解为插队）

package collection;
public class Demo7 implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i < 90; i++) {
            System.out.println("线程vip来了");
        }
    }
​
    public static void main(String[] args) throws InterruptedException {
        // 启动线程
        Demo7 d7=new Demo7();
        Thread thread=new Thread(d7);
        thread.start();
​
        // 主线程
        for (int i = 0; i < 100; i++) {
            if (i==90){
                thread.join();  // 插队
            }
            System.out.println("main"+i);
        }
    }
}

线程中断或结束，一旦进行死亡状态，就不能再次启动

线程优先级

（1）线程的优先级用数字表示，范围1-10，大则优先级高

（2）设置优先级：setPriority()，获取优先级：getPriority()

（3）优先级的设置要在start()调度前

（4）优先级低只是意味着获得调度的概率低，并不是优先级低就不会被调用

范例：（设置优先级）
package collection;
public class Demo7 implements Runnable {
    @Override
    public void run() {
        System.out.println("Thread "+Thread.currentThread().getName()+"----->"+Thread.currentThread().getPriority());
    }
    public static void main(String[] args) throws InterruptedException {
        Demo7 d1=new Demo7();
        Thread t1=new Thread(d1,"t1");
        Thread t2=new Thread(d1,"t2");
        Thread t3=new Thread(d1,"t3");
        Thread t4=new Thread(d1,"t4");
        t1.setPriority(1);  // 设置优先级
        t1 .start();  // 启动线程
        t2.setPriority(4);  // 设置优先级
        t2 .start();
        t3.setPriority(7);  // 设置优先级
        t3 .start();
        t4.setPriority(10);  // 设置优先级
        t4 .start();
        // 主线程，默认优先级
        System.out.println("main线程");
    }
}

守护（daemon）线程

（1）线程分为用户线程和守护线程

（2）虚拟机必须确保用户线程执行完毕

（3）虚拟不有等待守护线程执行完毕

范例：（守护线程）
package collection;
​
public class TextDaemon {
    public static void main(String[] args) {
        God god=new God();
        You you=new You();
        Thread thread=new Thread(god);
        //设置守护线程，setDaemon()默认为false,正常的线程是用户线程，
        thread.setDaemon(true);
        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 < 3650; i++) {
            System.out.println("你活了"+i+"天");
        }
        System.out.println("====================Godbye==================");
    }
}

线程同步

多个线程操作同一个资源 并发：同一个对象被多个线程同时操作

范例：（同步方法）
package collection;
​
public class Demo10 {
    public static void main(String[] args) {
        LLock ck=new LLock();
        new Thread(ck).start();
        new Thread(ck).start();
        new Thread(ck).start();
    }
}
​
class LLock implements Runnable{
    private int licket=10;
​
    @Override
    public synchronized void run() {
        while (true){
            if (licket>0){
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(licket--);
            }else {
                break;
            }
        }
​
    }
}

Lock（锁）

（1）使用ReentrantLock类实现Lock,可以显式加锁、解放锁

ReentrantLock可重用锁

synchronized与Lock

优先使用顺序：

Lock > 同步代码块（已经进入了方法体，分配了相应资源） > 同步方法（在方法体之外）

范例：（同步代码块）
package collection;
import java.util.concurrent.locks.ReentrantLock;
public class Demo10 {
    public static void main(String[] args) {
        LLock ck=new LLock();
        new Thread(ck).start();
        new Thread(ck).start();
        new Thread(ck).start();
    }
}
​
class LLock implements Runnable{
    private int licket=10;
    // 定义lock 锁
    private final ReentrantLock lock=new ReentrantLock();
​
    @Override
    public void run() {
        while (true){
            try{
                lock.lock(); // 加锁
                if (licket>0) {
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(licket--);
                }else{
                    break;
                }
            }finally {
                lock.unlock();  // 解锁
            }
        }
    }
}

范例：（同步）---生产者消费者模型
package text;
public class Text {
​
    public static void main(String[] args) {
        M m=new M();
        new P(m).start();
        new C(m).start();
    }
}
​
// 演员
class P extends Thread{
    private M m;
    public P(M m){
       this.m=m;
    }
    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            if(i%2==0){
                this.m.play("aaa");
            }else {
                this.m.play("bbb");
            }
        }
    }
}
​
// 观众
class C extends Thread{
    private M m;
    public C(M m){
        this.m=m;
    }
    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            this.m.watcher();
        }
    }
}
​
// 节目 
class M{
    private String name;
    boolean flag=true;
​
    public synchronized void play(String name){
        if(!flag){
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println("========表演"+name);
        // 通知欢众观看
        this.notify();
        this.name=name;
        this.flag=!this.flag;
    }
​
    public synchronized void watcher(){
        if (flag){
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println("观看"+name);
        //　通知演员表演
        this.notify();
        this.flag=!this.flag;
    }
}

线程池

（1）真正线程池接口：ExecutorService。常见子类ThreadPoolExecutor

（2）Executors：工具类、线程池的工厂类，用于创建并返回不同类型的线程池

// 创建服务，创建线程池，newFixedThreadPool , 参数为：线程池大小

ExecutorService service=Executors.newFixedThreadPool(10);

范例：
package text;
​
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
​
public class Text1 {
    public static void main(String[] args) {
        // 创建服务，创建线程池，newFixedThreadPool  , 参数为：线程池大小
        ExecutorService service=Executors.newFixedThreadPool(10);
        
        // 执行 
        service.execute(new MyThread());
        service.execute(new MyThread());
        service.execute(new MyThread());
        service.execute(new MyThread());
        
        // 关闭链接
        service.shutdown();
        
//      pool-1-thread-1
//      pool-1-thread-2
//      pool-1-thread-3
//      pool-1-thread-4
    }
}
​
class MyThread implements Runnable{
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName());
    }
}

这篇关于Lamda表达式、线程停止，休眠，礼让（yield）,join,优先级，守护（daemon）、同步、Lock、线程池的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！