C/C++教程
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不建议用的方法
线程方法
| 方法 | 说明 |
|---|---|
| setPriority(int newPriority) | 更改线程的优先级 |
| static void sleep(long millis) | 在指定的毫秒数内让当前正在执行的线程休眠 |
| void join() | 等待该线程终止 |
| static void yield() | 暂停当前正在执行的线程对象，并执行其他线程 |
| void interrupt() | 中断线程，不建议使用 |
| boolean isAlive() | 测试线程是否处于活动状态 |
范例：（停止线程）
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
| 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、线程池的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！
您可能喜欢
-
RocketMQ入门指南：搭建与使用全流程详解11-26
-
RocketMQ入门教程：轻松搭建与使用指南11-26
-
手写RocketMQ：从入门到实践的简单教程11-26
-
【机器学习(二)】分类和回归任务-决策树(Decision Tree,DT)算法-Sentosa_DSML社区版11-25
-
增量更新怎么做？-icode9专业技术文章分享11-23
-
压缩包加密方案有哪些？-icode9专业技术文章分享11-23
-
用shell怎么写一个开机时自动同步远程仓库的代码？-icode9专业技术文章分享11-23
-
webman可以同步自己的仓库吗？-icode9专业技术文章分享11-23
-
在 Webman 中怎么判断是否有某命令进程正在运行？-icode9专业技术文章分享11-23
-
如何重置new Swiper?-icode9专业技术文章分享11-23
-
oss直传有什么好处？-icode9专业技术文章分享11-23
-
如何将oss直传封装成一个组件在其他页面调用时都可以使用？-icode9专业技术文章分享11-23
-
怎么使用laravel 11在代码里获取路由列表？-icode9专业技术文章分享11-23
-
怎么实现ansible playbook 备份代码中命名包含时间戳功能？-icode9专业技术文章分享11-22
-
ansible 的archive 参数是什么意思？-icode9专业技术文章分享11-22
栏目导航
