5.线程

最新推荐文章于 2024-06-20 20:20:21 发布
最新推荐文章于 2024-06-20 20:20:21 发布
阅读量121 收藏
点赞数
分类专栏： JAVAWeb全栈 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42655231/article/details/108980976
版权

一.使用

1.第一种方式

//mythread
public class myClass extends Thread{

    public void run(){
        for (int i = 0; i < 20; i++) {
            System.out.println("run:"+i);
        }
    }
}

//main
public class helloJava {
    public static void main(String[] args) {
        myClass th = new myClass();
        th.start();

        for (int i = 0; i < 20; i++) {
            System.out.println("main"+i);
        }
    }
}

2.第二种方式

public class myClass implements Runnable{

    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            System.out.println("thread:"+i);
        }
    }
}


public class helloJava {
    public static void main(String[] args){
        myClass temp = new myClass();
        Thread imp = new Thread(temp);
        imp.start();

        for (int i = 0; i < 20; i++) {
            System.out.println("main:"+i);
        }
    }
}

3.内存图解

4.thread和Runable的区别

5.匿名内部类实现线程的创建

匿名内部类的作用：

  1. 把子类继承父类，重写父类方法，创建字类对象一气呵成
  2. 把实现类实现接口，重写接口方法，创建类对象一气呵成

 

public class main {
    public static void main(String[] args) {
        //匿名内部类

        //法1
        new Thread(){
            //重写run方法
            @Override
            public void run(){
                for (int i = 0; i < 10; i++) {
                    System.out.println("th1:"+i);
                }
            }
        }.start();

        //法2
        Runnable imp =  new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 10; i++) {
                    System.out.println("th2:"+i);
                }
            }
        };
        new Thread(imp).start();

        for (int i = 0; i < 20; i++) {
            System.out.println("main:" + i);
        }
    }
}

二.线程安全

mainTest:

public class main {
    public static void main(String[] args) {
        threadImp th = new threadImp();

        Thread th1 = new Thread(th);
        Thread th2 = new Thread(th);
        th1.start();
        th2.start();

        for (int i = 0; i < 3; i++) {
            System.out.println("main:" + i);
        }
    }
}

1.同步代码块

synchronized

public class threadImp implements Runnable {
    private int ticket = 10;
    @Override
    public void run() {
        while (true){
            synchronized (this) {
                if (ticket > 0) {
                    System.out.println("ticket:" + ticket);
                    ticket--;
                }
                if (ticket <= 0) {
                    break;
                }
            }
        }
    }
}

2.同步方法

同步方法：使用synchronized修饰的方法，就叫同步方法，保证A线程执行该方法的时候，其他线程只能再方法外等待
同步方法的锁对象是this
public class main {
    public static void main(String[] args) {
        threadImp th = new threadImp();

        Thread th1 = new Thread(th);
        Thread th2 = new Thread(th);
        th1.start();
        th2.start();

        for (int i = 0; i < 3; i++) {
            System.out.println("main:" + i);
        }
    }
}

静态同步方法：

main:

public class main {
    public static void main(String[] args) {
        //threadImp th = new threadImp();

        Thread th1 = new Thread(new threadImp());
        Thread th2 = new Thread(new threadImp());
        th1.start();
        th2.start();

        for (int i = 0; i < 3; i++) {
            System.out.println("main:" + i);
        }
    }
}

thread:

public class threadImp implements Runnable {
    private static int ticket = 10;
    @Override
    public void run() {
        fun();
    }

    public static synchronized void fun(){
        while (true){
            if (ticket > 0) {
                System.out.println("ticket:" + ticket);
                ticket--;
            }
            if (ticket <= 0) {
                break;
            }
        }
    }
}

静态方法只能访问静态成员变量；静态成员是类的所有对象中共享的成员，而不是某个对象的成员

3.锁机制

public class threadImp implements Runnable {
    private int ticket = 10;
    ReentrantLock loc = new ReentrantLock();
    @Override
    public void run() {
        fun();
    }

    public void fun(){
        loc.lock();
        while (true){
            if (ticket > 0) {
                System.out.println("ticket:" + ticket);
                ticket--;
            }
            if (ticket <= 0) {
                break;
            }
        }
        loc.unlock();
    }
}

main:

public class main {
    public static void main(String[] args) {
        threadImp th = new threadImp();

        Thread th1 = new Thread(th);
        Thread th2 = new Thread(th);
        th1.start();
        th2.start();

        for (int i = 0; i < 3; i++) {
            System.out.println("main:" + i);
        }
    }
}

三.等待唤醒机制

1.使用

public class main {
    public static boolean count = false;//有无包子的状态

    public static void main(String[] args) {

        ReentrantLock loc = new ReentrantLock();

        Runnable buy = new Runnable() {
            @Override
            public void run() {
                    while (true){
                        synchronized (loc){
                            System.out.println("消费者");
                            try {
                                loc.wait();
                            } catch (InterruptedException e) {
                                e.printStackTrace();
                            }
                            System.out.println("消费中");
                        }
                    }
            }
        };

        Runnable sell = new Runnable() {
            @Override
            public void run() {
                while (true){
                    try {
                        Thread.sleep(5000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }

                    synchronized (loc){

                        System.out.println("生产完成");
                        loc.notify();
                    }
                }
            }
        };


        new Thread(sell).start();
        new Thread(buy).start();

    }
}

2.生产者消费者模型

（1）第一版：同一个类

package cn.java.test;


/*
 */

import java.util.concurrent.locks.ReentrantLock;

public class main {
    public static boolean count = false;//有无包子的状态
    static ReentrantLock loc = new ReentrantLock();

    public static void main(String[] args) {

        Runnable buy = new Runnable() {
            @Override
            public void run() {
                    while (true){
                        synchronized (loc){
                            if(count == true){
                                try {
                                    loc.wait();
                                } catch (InterruptedException e) {
                                    e.printStackTrace();
                                }
                            }
                            System.out.println("正在生产");
                            try {
                                Thread.sleep(5000);
                            } catch (InterruptedException e) {
                                e.printStackTrace();
                            }
                            count=true;
                            System.out.println("生产完成");
                            loc.notify();//随机唤醒一个
                        }
                    }
            }
        };

        Runnable sell = new Runnable() {
            @Override
            public void run() {
                while (true){
                    synchronized (loc){
                        if(count == false){
                            try {
                                loc.wait();
                            } catch (InterruptedException e) {
                                e.printStackTrace();
                            }
                        }
                        System.out.println("正在吃");
                        try {
                            Thread.sleep(3000);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        count = false;
                        System.out.println("吃完了");
                        loc.notify();
                    }
                }
            }
        };

        new Thread(sell).start();
        new Thread(buy).start();
    }
}

（2）分文件

测试：

public class main {
    public static void main(String[] args) {
        obj a = new obj();
        sellPerson sell = new sellPerson(a);
        buyPerson buy = new buyPerson(a);
        new Thread(sell).start();
        new Thread(buy).start();
    }
}

物品：

public class obj{
    boolean flag=false;
}

生产者：

public class sellPerson implements Runnable{
    private obj temp;

    public sellPerson(obj temp) {
        this.temp = temp;
    }

    @Override
    public void run() {
        while(true) {
            synchronized (temp) {
                if (temp.flag == true) {
                    try {
                        temp.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                System.out.println("正在生产");
                try {
                    Thread.sleep(5000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

                temp.flag = true;
                System.out.println("生产完成");
                temp.notify();//随机唤醒一个
            }
        }
    }
}

消费者：

public class buyPerson implements Runnable {
    private obj temp;

    public buyPerson(obj temp) {
        this.temp = temp;
    }

    @Override
    public void run() {
        while(true){
            synchronized (temp){
                synchronized (temp){
                    if(temp.flag == false){
                        try {
                            temp.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                    System.out.println("正在吃");
                    try {
                        Thread.sleep(3000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    temp.flag = false;
                    System.out.println("吃完了");
                    temp.notify();
                }


            }
        }
    }
}

四.线程池使用

public class main {
    public static void main(String[] args) {

        ExecutorService ex = Executors.newFixedThreadPool(3);
        ex.submit(new threadImp());
        ex.submit(new threadImp());
        ex.submit(new threadImp());

        ex.shutdown();//不建议执行，执行完就结束了
    }
}
public class threadImp implements Runnable {
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName());
    }
}

五.lambda表达式

lambda是java8的一个新特性,格式由三部分组成，省去了面向对象的条条框框

  • 一些参数
  • 一个箭头
  • 一段代码

Lambda 允许把函数作为一个方法的参数（函数作为参数传递进方法中）。使用 Lambda 表达式可以使代码变的更加简洁紧凑

格式：（参数类型  参数名称）->（代码语句）

()：接口中抽象方法的参数列表，没有参数，就空着，有参数就写出参数，多个参数用逗号隔离

->：传递的意思，把参数传递给方法体

{}:重写接口的抽象方法的方法体

lambda的重要参数：

可选类型声明：不需要声明参数类型，编译器可以统一识别参数值。
可选的参数圆括号：一个参数无需定义圆括号，但多个参数需要定义圆括号。
可选的大括号：如果主体包含了一个语句，就不需要使用大括号。
可选的返回关键字：如果主体只有一个表达式返回值则编译器会自动返回值，大括号需要指定明表达式返回了一个数值。


（1）无参无返回

public interface Cook {
    public abstract void makeCook();
}

public class main {
    public static void main(String[] args) {
        //法1
        fun(new Cook(){
            @Override
            public void makeCook() {
                System.out.println("无lambda");
            }
        });

        //法2
        fun(()->{
            System.out.println("lambda");
        });

    }
    public static void fun(Cook cook){
        cook.makeCook();
    }
}

（2）参数和返回值

public class person {
    private int age;
    private String name;

    public person(int age, String name) {
        this.age = age;
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}
public class main {
    public static void main(String[] args) {
        person[] arr = {
                new person(18,"张三"),
                new person(19,"李四"),
                new person(17,"王五")
        };
/*
        Arrays.sort(arr, new Comparator<person>() {
            @Override
            public int compare(person o1, person o2) {
                return o1.getAge()-o2.getAge();
            }
        });

        for(person i:arr){
            System.out.println(i.getName()+i.getAge());
        }
*/
        Arrays.sort(arr,(person o1,person o2)->{
            return o1.getAge()-o2.getAge();
        });

        for(person i:arr){
            System.out.println(i.getName()+i.getAge());
        }
    }
}

例2：

public interface Cook {
    public abstract int makeCook(int a,int b);
}
public class main {
    public static void main(String[] args) {
        //调用cal方法,方法的参数是一个接口，可以采用匿名内部类
        cal(2, 3, new Cook() {
            @Override
            public int makeCook(int a, int b) {
                return a+b;
            }
        });
        
        //lambda表达式
        cal(4,5,(int a,int b)->{
            return a+b;
        });
    }

    /*
    定义一个方法：传递两个整数和一个接口
    计算两个整数的和
     */
    public static void cal(int a,int b,Cook cook){
        int c = cook.makeCook(a,b);
        System.out.println(c);
    }
}

（3）参数的省略

可以省略：
1.括号内参数的类型可以省略
2.如果小括号内，有且仅有一个参，小括号可以省略
3.如果大括号内有且仅有一个语句，则无论是否有返回值，都可以省略({},return,;)
  注意：要省略，必须三个一起省略
public class main {
    public static void main(String[] args) {
        
        //3.例子
        new Thread(()->{
            System.out.println("3:省略前");
        }).start();
        new Thread(()-> System.out.println("3:省略后")).start();

        // 1 和 3
        person[] arr = {
                new person(18,"张三"),
                new person(19,"李四"),
                new person(17,"王五")
        };

        Arrays.sort(arr,(o1, o2)->o1.getAge()-o2.getAge());

        for(person i:arr){
            System.out.println(i.getName()+i.getAge());
        }
    }
}

注意：

lambda使用方法非常简洁，完全没有面向对象复杂的束缚，但是是羊奶粉的时候必须要注意几点
1.使用lambda必须有抽象方法，而且抽象方法必须有且仅有一个抽象方法
2.使用lambda必须有上下文推断
  即：方法的参数或者局部变量类型必须为Lambda对应的接口类型，才能使用lambda作为给实例的接口
备注：有且仅有一个抽象方法的接口，成为“函数式接口”
want you tell me why
关注
专栏目录
Qt5 多线程
09-12
Qt5多线程讲解，简单易懂，适合初学者，介绍了多线程各种优缺点
PyQt5多线程的执行和停止
03-18
实现三个线程同时执行，且可以单独关闭和运行，通过进度条实现可视化演示。
C#多线程和异步（二）——Task和async/await详解
jy_1005的博客
04-18 3289
通过上边的介绍，我们知道async/await是基于Task的，而Task是对ThreadPool的封装改进，主要是为了更有效的控制线程池中的线程(ThreadPool中的线程，我们很难通过代码控制其执行顺序，任务延续和取消等等)；当线程池中所有的线程都在忙碌时，又有新任务要处理时，线程池才会新建一个线程来处理该任务，如果线程数量达到设置的最大值，任务会排队，等待其他任务释放线程后再执行。②如果我们想让所有的线程执行完毕(或者任一线程执行完毕)时，立即解除阻塞，使用Join方法不容易实现。
【Java学习】线程（Thread）
m0_49831249的博客
07-16 296
多线程指两个或多个事件在同⼀个时间段内发⽣（同时发⽣）。
java中启动线程的两种方式
雪糕的博客
08-26 878
java线程启动方式
进程和线程的区别和联系
xiaoyubuhuiqiche的博客
03-18 5194
从认识线程到线程是如何共享了进程的资源进行了详细的讲解
[PyQt5] 线程刷新界面
藏知阁
07-10 4万+
PyQt5线程刷新界面
PyQT5 多线程 QThread
Persus & Xie
03-29 1万+
PyQT5 多线程 在常规的界面软件中，需要将UI线程和工作线程加以区分，主要原因是某些工作线程很复杂且耗时，比如下载某个文件或者长时间的计算，当执行这些进程时，UI主进程会被阻塞，界面会出现未响应的状态，所以需要用到多线程来解决这个问题。 QThread QThread是QT线程类中最核心的底层类。由于PyQt的跨平台特性，QThread要隐藏所有与平台相关的代码，可以先创建它的子类，然后覆盖本身所有的QThread.run()函数。 import time from PyQt5.QtCore impor
vert.x线程安全的线程模型详解
sdmjhca的专栏
10-19 5272
原文地址：http://www.sczyh30.com/posts/Vert-x/vertx-advanced-demystifying-thread-model/ 线程模型概述 Vert.x的线程模型设计的非常巧妙。总的来说，Vert.x中主要有两种线程：Event Loop线程 和 Worker线程。其中，Event Loop线程结合了Netty的EventLoop，用于处理
【Java并发编程 基础】5.守护线程
terrybg
06-03 1万+
在java中有两种线程：用户线程，守护线程。 用户线程 指用户创建的线程，主线程停止用户线程不会停止 守护线程 当进程结束或主线程停止，守护线程也会停止守护线程和main相关（主线程），gc线程（垃圾回收器）也是守护线程，当主线程死掉后，gc线程也会死。用户线程和主线程例子: 当主线程执行完毕后，用户线程依然在执行主线程和守护线程例子： 可以看到主线程执行完后，守护线程就不会执行完了，虽然执行到了16
Java多线程超详解
热门推荐
weixin_44797490的博客
06-11 14万+
引言 随着计算机的配置越来越高，我们需要将进程进一步优化，细分为线程，充分提高图形化界面的多线程的开发。这就要求对线程的掌握很彻底。 那么话不多说，今天本帅将记录自己线程的学习。 线程的相关API //获取当前线程的名字 Thread.currentThread().getName() 1.start():1.启动当前线程2.调用线程中的run方法 2.run():通常需要重写Thread类中的此...
pyqt5多线程使用方法及学习案例（QThread）
小屋
03-24 3746
在使用pyqt5的过程中，会存在界面卡死的现象，为了优化改善，可以利用多线程来解决此类问题。可以实现信号与槽在多个线程中的相互传递数据。 用法很简单，创建一个进程类，不同触发时刻分别调用即可。 参考案例一：来源《PyQT5线程：多线程(QThread)，线程锁(QMutex)》 实现两个线程来在工作台显示不同打印信息。 from PyQt5.Qt import (QApplication, QWidget, QPushButton, QThread,QMutex,
HTML5之多线程(Web Worker)
09-22
HTML5的多线程特性，即Web Worker，是为了解决JavaScript单线程运行的问题而引入的一个重要功能。JavaScript作为一种浏览器脚本语言，其单线程特性是为了避免复杂的同步问题，确保DOM操作的一致性。然而，随着互联网...
11.Linux线程同步
01-06
文章目录一、线程同步的概念二、互斥锁1、初始化锁2、阻塞加锁3、非阻塞加锁4、解锁5、销毁锁（此时锁必需unlock状态，否则返回EBUSY）三、示例程序四、版权声明 一、线程同步的概念 线程同步？怎么同步？一起运行？...
多线程.pdf
08-06
Java线程有10个优先级，1至10，10为最高优先级（`MAX_PRIORITY`），1为最低优先级（`MIN_PRIORITY`），5为默认优先级（`NORM_PRIORITY`）。优先级高的线程有更大的概率获取CPU执行时间。 ### 9. 多线程问题与解决 ...
数据结构与算法-差分数组及应用
qq_36115196的博客
06-20 506
差分数组： 其实差分数组是创建一个一个辅助数组，用来表示给定数组的变化，一般用来对数组进行区间修改的操作。
Day43
最新发布
m0_67496588的博客
06-20 531
JSON，Ajax
Java 中 什么是 lambda 表达式？有什么优点？
liangzai215的专栏
06-13 934
但是，Lambda 表达式绝对不是 Java 8 的银弹，它在消除代码冗余、支持并发这两方面表现优秀，但是在其他方面并未有太多贡献，所以我们在编程的时候，还是需要结合实际情况，灵活选择使用。Lambda表达式在Java 8中是非常强大的工具，但是需要注意的是，Lambda并并不适合所有情况，它主要适用于函数式编程，处理集合操作和Stream操作，在某些具体的业务逻辑操作中就不一定会产生预期的效果。代码块：是 Lambda 表达式需要执行的功能，可以是一行代码，也可以是复杂的多行代码。
基于springboot的青年公寓服务平台源码数据库
s123456sj的博客
06-16 1205
本青年公寓服务平台分为管理员还有用户两个权限，管理员可以管理用户的基本信息内容，可以管理房屋投诉信息以及房屋投诉的租赁信息，能够与用户进行相互交流等操作，用户可以查看房屋信息，可以查看房屋投诉以及查看管理员回复信息等操作。
1. 什么是线程 2. 为什么要引进线程 3. 线程和进程的区别 4. 什么是用户级线程 5. 什么是内核级线程 6. 用户级和内核级线程之间的区别
02-21
5. 内核级线程是指由操作系统内核创建和管理的线程，由操作系统内核负责管理线程的调度和上下文切换。6. 用户级线程和内核级线程的区别在于，用户级线程是由用户程序管理的，而内核级线程是由操作系统内核管理的。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值