java线程

最新推荐文章于 2024-09-14 18:46:05 发布
最新推荐文章于 2024-09-14 18:46:05 发布
阅读量47 收藏
点赞数
分类专栏： 线程 文章标签： java
原文链接：https://blog.csdn.net/qq_42647047/article/details/113953589?
版权
本文详细讲解了线程创建的两种方式、Runnable接口的应用、Callable接口、并发代理模式、线程状态与控制、死锁及其解决、锁机制（Lock）及同步方法与同步块，助您理解并解决并发编程中的关键问题。
摘要由CSDN通过智能技术生成

文章目录

线程的创建

1、继承thread类（重点）

在这里插入图片描述
在这里插入图片描述

2、实现Runnable接口【推荐使用这种方法，应对Java单继承的局限性】

在这里插入图片描述

3、实现callable接口（了解）

lamda表达式

在这里插入图片描述

在这里插入图片描述
在这里插入图片描述

并发

静态代理模式

package Demo02;
//静态代理模式总结:
//1、真实对象（You）和代理对象（WeddingCompany）都要实现同一个接口。
//2、代理对象要代理真实对象（即，代理对象要有一个参数，把真实对象传进去）
//好处：
//1、代理对象可以做真实对象做不了的事情
//2、真实对象就可以专注做自己的事情；

//线程的Runnable创建方式就是：线程的代理模式。因为Thread和丢进Thread的Runnable接口实现类，都实现Runnable接口。

public class StaticProxy {
    public static void main(String[] args) {
    	//真实对象，需要传入代理对象
        You you = new You();
        //代理对象
        WeddingCompany weddingCompanynew =  new WeddingCompany(you);
        weddingCompanynew.HappyMarry();

        //线程的Runnable创建方式就是：线程的代理模式。因为Thread和丢进Thread的Runnable接口实现类，都实现Runnable接口。
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("我爱你");
            }
        }).start();
    }
}

//真实对象 和 代理对象 都要实现的同一个接口；
interface Marry{
    void HappyMarry();
}

//真实对象---You;
class You implements Marry{
    @Override
    public void HappyMarry() {
        System.out.println("秦老师要结婚了，超开心");
    }
}

//代理对象----WeddingCompany婚庆公司
class WeddingCompany implements Marry{
    //代理对象首先要有个被代理的对象；
    private Marry target;
    // 代理对象要代理真实对象，所以要是用构造方法传入真实对象
    public WeddingCompany(Marry target) {
        this.target = target;
    }

    @Override
    //代理对象的重写方法里，即有真实对象做的事，也有真实对象做不了的事before()，after();
    public void HappyMarry() {
        before();
        this.target.HappyMarry();
        after();
    }

    private void before(){
        System.out.println("结婚之前，布置现场");
    }

    private void after(){
        System.out.println("结婚之后，收尾款");
    }
}

   
   

   
   
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66

线程的状态

在这里插入图片描述

下面是五个状态的详解：

  • new代表创建状态
  • dead代表死亡状态
    在这里插入图片描述

线程的方法

在这里插入图片描述

停止线程

在这里插入图片描述

线程休眠

在这里插入图片描述

package Demo03;

public class TestSleep {
    public static void main(String[] args) {
        try {
            tenDown();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    public static void tenDown() throws InterruptedException{
        int num = 10;
        while(true){
            Thread.sleep(1000);//运行的线程延时1s
            System.out.println(num--);
            if(num<=0) break;
        }
    }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20

线程礼让

在这里插入图片描述
代码：

package Demo03;

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() + "线程停止执行");
    }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19

线程强制执行

在这里插入图片描述

线程状态观测

在这里插入图片描述
代码：

package Demo03;

public class TestState {
    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(()->{
            for (int i = 0; i < 5; i++) {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("/");

            }
        });

        //观察状态；
        Thread.State state = thread.getState();
        System.out.println(state);//NEW.  因为还未条用start开始线程，所以状态为NEW

        //观察启动后状态
        thread.start();
        state = thread.getState();//更新线程状态。即，获取现在线程的状态。
        System.out.println(state);//RUNNABLE

        while(state != Thread.State.TERMINATED){//判断线程是否死亡，不死亡的情况下，输出线程启动后的状态
            Thread.sleep(100);//TIMED_WAITING
            state = thread.getState();//更新线程状态;
            System.out.println(state);
        }
    }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33

线程优先级

在这里插入图片描述

  • 10优先级最高，1优先级最低；优先级高的被先执行的概率大。
  • 设置高优先级数字，只是这个线程被CPU调度的概率权重高了。实际上CPU还是随机调度线程，所以优先级高的线程不一定先执行，只是先执行的概率高。
  • 优先级高的后执行------------------>这种情况叫：性能倒置。

守护线程

在这里插入图片描述

  • 用户线程：比如main函数体里的线程；
  • 守护线程：比如gc函数（垃圾回收（Garbage collection）机制，自动完成，我们看不到）。
  • setDaemon()来设置是用户线程还是守护线程，默认参数是false：用户线程；参数为true为守护线程
thread.setDaemon(true);

 
 

 
 
  • 1

线程的同步

  • 线程同步是解决并发问题的
  • 什么是线程同步：
    比如两个人（每一个人代表一个线程）买票，票共10张，一个人要买6张票，另一个人也要买6张。两个人同时买票，票数是不够的，这时票数会变成-2张，这就是并发问题。所以需要线程同步，即一个人买后，票数同步更新，下一个人再买，发现票数不够，就不能买了。这就需要队列+锁。

简单来说：线程同步，同步的是被修改的部分，使修改实时同步。

在这里插入图片描述

线程同步需要队列+锁

1、为什么需要队列排队

在这里插入图片描述

2、为什么需要锁

比如一群人排队上厕所，只排好队一个一个的进厕所，会出现厕所里人越来越多，导致厕所没那么多空间储存那么多人。一个好的方法是在厕所门上装一个锁，进去一个人，就上锁，等这个人上完厕所，再开锁，让下一个人进。这样就可以解决空间问题。
在这里插入图片描述

线程同步方法

在这里插入图片描述

  • 因为同步的是修改的部分，所以用关键字synchronized锁住的部分为需要修改的部分，不需要修改的部分不用锁 。若锁的太多，会浪费资源。
  • 需锁的部分一般在线程里，因为线程同步解决的是线程的并发问题，所以锁的部分当然在线程里：
    1、同步方法一般锁的是线程里的有修改功能的方法；
    2、同步块一般锁线程里的run方法中发生改变的对象；
    在这里插入图片描述
同步块

  • 同步监视器Obj监视的对象是需要修改的对象，即，需要增删改的对象。
    在这里插入图片描述

  • 下面是一个不安全的，存在并发情况的银行取钱案例

package Demo03;

public class UnsafeBank {
    public static void main(String[] args) {
        Account account = new Account(100, "结婚基金");

        Drawing you = new Drawing(account, 50, "你");
        Drawing girlFriend = new Drawing(account, 100, "girlFriend");

        you.start();
        girlFriend.start();
    }
}

//账户
class Account{
    int money;//余额
    String name;//卡名

    public Account(int money, String name) {
        this.money = money;
        this.name = name;
    }
}

//银行：模拟取款; Drawing:取钱
class Drawing extends Thread{
    //取钱首先要有个账户
    Account account;
    //取了多少钱
    int drawingMoney;
    //还剩多少钱
    int nowMoney;
    public Drawing(Account account, int drawingMoney, String name){
        super(name);
        this.account = account;
        this.drawingMoney = drawingMoney;
    }

    @Override
    public void run() {
        //首先判断有没有钱
        if(account.money - drawingMoney <0){
            System.out.println(Thread.currentThread().getName() + "钱不够了，取不了");
            return;
        }
        //利用延时放大问题的发生性
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        //卡内余额 = 余额 - 取得钱
        account.money = account.money - drawingMoney;
        //手里的钱
        nowMoney = nowMoney + drawingMoney;
        System.out.println(account.name + "余额为：" + account.money);
        //Thread.currentThread().getName() = this.getName()
        System.out.println(this.getName() + "手里的钱：" + nowMoney);
    }
}

 
 

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 这里是从账户取钱，所以修改的对象是account，在线程的run函数里加入synchronized 块，包含account的代码都放在synchronized 块中即可。
    @Override
    public void run() {

        synchronized (account){
            //首先判断有没有钱
            if(account.money - drawingMoney <0){
                System.out.println(Thread.currentThread().getName() + "钱不够了，取不了");
                return;
            }
            //利用延时放大问题的发生性
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            //卡内余额 = 余额 - 取得钱
            account.money = account.money - drawingMoney;
            //手里的钱
            nowMoney = nowMoney + drawingMoney;
            System.out.println(account.name + "余额为：" + account.money);
            //Thread.currentThread().getName() = this.getName()
            System.out.println(this.getName() + "手里的钱：" + nowMoney);
        }

    }
}

 
 

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26

死锁

  • 死锁概念
    在这里插入图片描述
    例子：两个女孩化妆
    共有一个镜子和一个口红，两个女孩化妆；一个女孩拿着镜子，一个女孩拿着口红，他们分别还想要对方手里的，如果对方不放自己手里的东西，那她们会一直等下去，造成死锁，导致程序卡死。只有双方都放开自己手里的东西，死锁才会解决。

死锁的代码：原因是 synchronized同步块同时包含两个锁

package Demo03;

//死锁：多个线程互相抱着对方的资源（互相抱着对方需要的锁），然后形成僵持
public class DeadLock {
    public static void main(String[] args) {
        Makeup girl1 = new Makeup(0, "灰姑凉");
        Makeup girl2 = new Makeup(1, "白雪公主");

        girl1.start();
        girl2.start();
    }
}

//口红
class Lipstick{}

//镜子
class Mirror{}

//线程做的是化妆（makeup）这件事
class Makeup extends Thread{
    //需要的资源只有一份（即，只有一个口红和一个镜子），用static来保证只有一份；
    //限定一份是为了模拟死锁
    static Lipstick lipstick = new Lipstick();
    static Mirror mirror = new Mirror();

    int choice;//选择哪个人化妆
    String girlName;//使用化妆品的人
    public Makeup(int choice, String girlName){
        this.choice = choice;
        this.girlName = girlName;
    }

    @Override
    public void run() {
        //化妆
        try {
            makeup();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    private void makeup() throws InterruptedException {
        if(choice == 0){
            synchronized (lipstick){//同步块获得lipstick的锁
                System.out.println(this.girlName + "获得口红的锁");
                Thread.sleep(1000);
                synchronized (mirror){//一秒钟后，同步块获得mirror的锁
                    System.out.println(this.girlName + "获得镜子的锁");
                }
            }
        }else{
            synchronized (mirror){//同步块获得mirror的锁
                System.out.println(this.girlName + "获得镜子的锁");
                Thread.sleep(1000);
                synchronized (lipstick){//一秒钟后，同步块获得lipstick的锁
                    System.out.println(this.girlName + "获得口红的锁");
                }
            }
        }
    }
}

 
 

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64

结果：死锁
在这里插入图片描述

解决办法：把两个锁中的一个，放在同步块外面，不让一个同步块同时包含两个锁就行。

private void makeup() throws InterruptedException {
        if(choice == 0){
            synchronized (lipstick){//同步块获得lipstick的锁
                System.out.println(this.girlName + "获得口红的锁");
                Thread.sleep(1000);
            }
            synchronized (mirror){//一秒钟后，同步块获得mirror的锁
                System.out.println(this.girlName + "获得镜子的锁");
            }
        }else{
            synchronized (mirror){//同步块获得mirror的锁
                System.out.println(this.girlName + "获得镜子的锁");
                Thread.sleep(1000);
            }
            synchronized (lipstick){//一秒钟后，同步块获得lipstick的锁
                System.out.println(this.girlName + "获得口红的锁");
            }
        }
    }

 
 

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19

结果
在这里插入图片描述

死锁避免方法

在这里插入图片描述

Lock(锁)

在这里插入图片描述

  • ReentratLock：可重入锁

例子：买票

package Demo03;

import java.util.concurrent.locks.ReentrantLock;

public class TestLock {
    public static void main(String[] args) {
        TestLock2 testLock2 = new TestLock2();
        new Thread(testLock2).start();
        new Thread(testLock2).start();
        new Thread(testLock2).start();
    }
}

class TestLock2 implements Runnable{
    int ticketNums = 10;
    //定义锁
    private final ReentrantLock lock = new ReentrantLock();

    @Override
    public void run() {
        while (true){
            //lock.lock();//加锁，或放这
            try{
                //票数ticketNums变化，所以在这加锁
                lock.lock();//加锁
                if(ticketNums>0){
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(ticketNums--);
                }else break;
            }finally {
                lock.unlock();//解锁
            }

        }
    }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43

在这里插入图片描述

Lock锁代码模板
在这里插入图片描述

OpenSource_
关注
专栏目录
JAVA线程同步
miqq_79872135的博客
03-23 2922
线程同步 线程同步：即当有一个线程在对内存进行操作时，其他线程都不可以对这个内存地址进行操作，直到该线程完成操作， 其他线程才能对该内存地址进行操作，而其他线程又处于等待状态，实现线程同步的方法有很多。 为什么要创建多线程？ 在一般情况下，创建一个线程是不能提高程序的执行效率的，所以要创建多个线程。 为什么要线程同步 多个线程同时运行的时候可能调用线程函数，在多个线程同时对同一个内存地址进行写入，由于CPU时间调度上的问题，写入数据会被多次的覆盖，所以就要使线程同步。 例如：我们去银行存钱，那肯定
Java线程休眠
选择目标，然后保持热爱。
04-11 2660
线程休眠 线程休眠：Thread.sleep(); sleep(时间)指当前线程阻塞的毫秒数； （1000毫秒 = 1秒） sleep存在异常InterruptedException; sleep时间达到后线程进入就绪状态； sleep可以模拟网络延时，倒计时等； 每一个对象都有一个锁，sleep不会释放锁。 sleep():模拟网络延时最大的作用：放大问题的发生性 public class SleepTest implements Runnable{ private int num
02Java线程模型
爱丹丹的博客
11-20 1479
线程有哪几种实现方式？Java线程与操作系统线程之间又有什么关系呢？
Java线程
热门推荐
sunyingboaini的博客
06-20 1万+
线程的使用
Java线程阻塞
qq_43966957的博客
12-06 4878
Java线程阻塞
Java 线程 基础知识总结
Zhangguohao666的博客
07-27 6298
文章目录线程基础生产消费者模型，synchronizedjoin方法+死锁（哲学家进餐问题）join和锁死锁有趣的Timer类Timer多线程的一个运行实例 初步认识下线程，线程怎么去实现（通过继承Thread或者实现Runnable接口） 线程基础 很不严谨的说，线程是什么？线程就是为了让很多个东东并发执行，大大的提高程序执行的效率啊 三个非常重要的概念： 程序：一组写好了的静态代码块（就我...
Java 线程的使用
weixin_53472653的博客
06-02 3369
尚硅谷学习笔记
java线程执行方法_java线程的常用方法
weixin_42300040的博客
02-20 2071
java线程的常用方法编号方法说明1public void start()使该线程开始执行；Java 虚拟机调用该线程的 run 方法。2public void run()如果该线程是使用独立的 Runnable 运行对象构造的，则调用该 Runnable 对象的 run 方法；否则，该方法不执行任何操作并返回。3public final void setName(String name)改变线程...
java线程问题排查
mynameisjinxiaokai的博客
10-27 1453
可视化查看内存、线程、类、VM等信息；选择序号进入需要查找的进程，进入命令行。2、根据进程PID 查找需要的信息。cmd命令窗口，通过jps查看。1、查看java进程的方式。jconsole 连接查看。
java打印线程堆栈_Java问题定位之Java线程堆栈分析
weixin_33016287的博客
02-13 1470
采用Java开发的大型应用系统越来越大，越来越复杂，很多系统集成在一起，整个系统看起来像个黑盒子。系统运行遭遇问题(系统停止响应，运行越来越慢，或者性能低下，甚至系统宕掉)，如何速度命中问题的根本原因是我们接下来讲的目的。本系列文章将Java问题定位的方法体系化，提供一种以黑盒子方式进行问题定位的思路：如何使用线程堆栈进行性能瓶颈分析？如何分析内存泄漏？如何分析系统挂死？目录总述如何输出线程堆栈？...
Java 线程
06-01
NULL 博文链接：https://yangeoo.iteye.com/blog/2219492
Java线程间同步互斥
03-17
Java线程间同步互斥，在实际的编程中，经常要处理线程间的同步互斥问题。Java 语言内在强大的多线程支持使得处理这类问题变得相对来说比较简单。本例将模仿经典的线程同步互斥例子——生产者和消费者问题，来演示 　...
Java 线程状态、线程池
01-20
java 线程状态、线程池 1. java 的线程状态 状态 发生条件 NEW 线程刚刚被创建，没有启动，没有调用start方法 RUNNABLE(可运行) 线程已经在JVM中运行，但是是否运行不确定，看当前线程是否由CPU执行权 ...
ｊａｖａ线程
09-28
程研究了线程的基础知识— 线程是什么、线程为什么有用以及怎么开始编写使用线程的简单 程序。 我们还将研究更复杂的、使用线程的应用程序的基本构件— 如何在线程之间交换数据、如何控制 线程以及线程如何互相通信...
Java线程模型缺陷
01-08
Java 编程语言的线程模型可能是此语言中最薄弱的部分。它完全不适合实际复杂程序的要求，而且也完全不是面向对象的。本文建议对 Java 语言进行重大修改和补充，以解决这些问题。 Java 语言的线程模型是此语言的一个...
Java-网络
最新发布
2301_81543552的博客
09-14 701
Java中的网络编程主要涉及使用Socket类进行网络通信，以及理解各种网络协议。以下是一些关键概念和示例代码，帮助您入门。
Android Studio 2024与2022 解决Read timed out和connect timed out的问题
2301_80035882的博客
09-14 615
如果在新建Android项目时报错：Read timed out或者connect timed out。
自动生成不重复的订单id
ClaireCheney的博客
09-13 285
【代码】自动生成不重复的订单id。
Java项目: 基于SpringBoot+mybatis+maven课程答疑系统(含源码+数据库+毕业论文)
weixin_43860634的博客
09-14 712
Java项目: 基于SpringBoot+mybatis+maven课程答疑系统(含源码+数据库+毕业论文)
Java线程优先级详解
"Java线程的优先级管理是多线程编程中的一个重要概念，它涉及到线程调度和执行的顺序。在Java中，线程的优先级被用来影响线程被操作系统选择执行的概率，但并不保证高优先级的线程一定会先于低优先级的线程执行。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值