多线程学习笔记

最新推荐文章于 2024-09-05 10:39:00 发布
最新推荐文章于 2024-09-05 10:39:00 发布
阅读量116 收藏
点赞数
分类专栏： Java 文章标签： 多线程 java thread
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_40936337/article/details/110731275
版权

线程优先级

Java提供一个线程调度器来监控程序中启动后进入就绪状态的所有线程，线程调度器按照优先级决定应该调度哪个线程来执行。

线程的优先级用数字表示，范围0-10

优先级设置建议在start()方法前。

优先级低只是意味着获得调度的概率低，并不是优先级低就不会被调用。这都是看CPU如何调度。

package State;

//测试优先级
public class TestPriority implements Runnable {

    public static void main(String[] args) {
        System.out.println(Thread.currentThread().getName() + "main方法 -->" + Thread.currentThread().getPriority());
        TestPriority priority = new TestPriority();
        Thread t1 = new Thread(priority);
        Thread t2 = new Thread(priority);
        Thread t3 = new Thread(priority);
        Thread t4 = new Thread(priority);
        Thread t5 = new Thread(priority);

        t1.setPriority(Thread.MAX_PRIORITY);
        t1.start();

        t2.setPriority(3);
        t2.start();

        t3.setPriority(5);
        t3.start();

        t4.setPriority(Thread.MIN_PRIORITY);
        t4.start();

        t5.setPriority(8);
        t5.start();
    }
    @Override
    public void run() {

        System.out.println(Thread.currentThread().getName() + "优先级 -->" + Thread.currentThread().getPriority());
    }
}

停止线程

不推荐使用JDK提供的stop(),destory()方法。推荐线程自己停下来。

建议使用一个标志位进行终止变量，当flag = false，则终止线程运行。

设置一个公开的方法停止线程，转换标志位。

线程休眠

sleep（时间）：指定当前线程阻塞的毫秒数；

sleep存在异常InterruptedException;

sleep时间达到后线程进入就绪状态；

sleep可以模拟网络延时，倒计时等；

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

package State;

import java.text.SimpleDateFormat;
import java.util.Date;

public class TestSleep {

    public static void main(String[] args) {
        //打印系统当前时间
        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();
            }
        }

    }

    public static void tenDown() throws InterruptedException {
        int num = 10;
        while (true) {
            Thread.sleep(1000);
            System.out.println(num--);
            if (num <= 0) {
                break;
            }
        }

    }
}

线程礼让（yield）

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

将线程从运行态转为就绪态。

让CPU重新调度，礼让不一定成功！看CPU心情

package State;

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() + "线程结束执行");
    }
}

//执行结果
A线程开始执行
B线程开始执行
A线程结束执行
B线程结束执行

Join 线程强制执行

join合并线程，待此线程执行完毕后，再执行其他线程，其他线程阻塞。

类似插队。

package State;

public class TestJoin implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println("线程VIP来了...." + i);
        }
    }

    public static void main(String[] args) throws InterruptedException {
        TestJoin testJoin = new TestJoin();
        Thread thread = new Thread(testJoin);
        thread.start();

        //主线程
        for (int i = 0; i < 500; i++) {
            if (i == 100) {
                thread.join();
            }
            System.out.println("主线程...." + i);
        }
    }
}

//执行结果
主线程....0
.......
主线程....99
线程VIP来了....0
.....
线程VIP来了....99
主线程....100
.........
主线程....499

守护线程

线程分为用户线程和守护线程。

虚拟机必须确保用户线程执行完毕；

不需要等待守护线程执行完毕。

package State;

//测试守护线程
public class TestDaemon {
    public static void main(String[] args) {
        God god = new God();
        YOU you = new YOU();

        Thread thread = new Thread(god);
        //true表示将线程更改为守护线程，默认为false=用户线程
        thread.setDaemon(true);

        thread.start();
        new Thread(you).start();
    }
}

class God implements Runnable {
    @Override
    public void run() {
        while (true) {
            System.out.println("God bless you");
        }
    }
}

class YOU implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i <= 200; i++) {
            System.out.println("开心的活着");
            if (i >= 200) {
                System.out.println("=======Good bye======");
            }
        }
    }
}

//运行结果
只要用户线程执行完毕，代码终止运行，不会再浪费资源去等待守护线程运行完毕

线程同步

线程同步：多个线程操作同一个资源。

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

处理多线程问题时，多个线程访问同一个对象，并且某些线程还想修改这个对象。这时候就需要线程同步。、

线程同步其实就是一种等待机制，多个需要同时访问此对象的线程进入这个对象的等待池形成队列，等待前面线程使用完毕，下一个线程再使用。

要形成线程同步则需要队列+锁

synchronized 锁机制

当一个线程获得对象的排它锁，独占资源，其他线程必须等待，使用后释放锁即可。

问题：

  1. 一个线程持有锁会导致其他所有需要此锁的线程挂起；

  2. 在多线程竞争下，加锁，释放锁会导致比较多的上下文切换和调度延时，引起性能问题。

  3. 如果一个优先级高的线程等待一个优先级低的线程释放锁，会导致优先级倒置，引起性能问题。

同步方法：

​ 由于我们可以通过private关键字来保证数据对象只能被方法访问，所以我们只需要对方法提出一套机制，这套机制就是synchronized关键字，既可以修饰方法，又可以修饰代码块

synchronized方法控制对“对象”的访问，每个对象对应一把锁，每个synchronized方法都必须获得调用该方法的对象的锁才能执行，否则线程会阻塞，方法一旦执行，就独占该锁，知道该方法返回才释放锁，后面被阻塞的线程才能获得这个锁，继续执行。

缺陷：若将一个大的方法申明为synchronized将会影响效率。

方法里需要修改的内容才需要加锁，锁的太多，浪费资源。

synchronized (obj) {
    
}

obj同步监视器，可以是任何对象，但是推荐使用共享资源作为同步监视器。

同步方法中不需要指定同步监视器，因为同步方法中的监视器就是对象本身或者是class。

执行过程：

  1. 第一个线程访问，锁定同步监视器，执行其中代码
  2. 第二个线程访问，发现同步监视器被锁定，无法访问
  3. 第一个线程访问完毕，解锁同步监视器
  4. 第二个线程访问，发现同步监视器没有锁，然后锁定并访问
package syn;

//安全的取钱
public class safeBank {
    public static void main(String[] args) {
        Account account = new Account(100,"结婚基金");
        Drawing drawing = new Drawing(account,50,"小明");
        Drawing drawing2 = new Drawing(account,100,"小红");
        drawing.start();
        drawing2.start();
    }
}

class Account{
    int money;
    String name;

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

//银行:模拟取款
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() {
        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 -= drawingMoney;
            //现在手里的现金 = 取出的金额 + 原有的现金
            nowMoney += drawingMoney;
            System.out.println(account.name+"余额为："+account.money + "\n" +this.getName() +
                    "手里的现金" + nowMoney);
        }

    }
}

死锁

多个线程各自占有一些资源，并且相互等待其他线程占有的资源才能运行，而导致两个或者多个线程都在等待对方释放资源，都停止执行的情形。某一个同步块同时拥有“两个以上对象的锁”时，就可能发生死锁问题。

package thread;

//死锁：多个线程互相抱着对方需要的资源，然后形成僵持，造成死锁。
public class DeadLock {
    public static void main(String[] args) {
        MakeUp g1 = new MakeUp(0,"Emily");
        MakeUp g2 = new MakeUp(1,"Emma");

        g1.start();
        g2.start();
    }
}

class LipStick {

}
class Mirror{

}
class MakeUp extends Thread {
    //用静态修饰，保证只有一份
    static LipStick lipStick = new LipStick();
    static Mirror mirror = new Mirror();
    //选择
    int choice;
    //使用化妆品的人
    String name;

    MakeUp(int choice,String name) {
        this.choice = choice;
        this.name = name;
    }
    @Override
    public void run() {
        //化妆
        try {
            makeUp();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    //同时抱两个锁会造成死锁，只需要不抱对方的锁就可以继续运行
    private void makeUp() throws InterruptedException {
        if (choice == 0) {
            System.out.println(this.name + "获得口红的锁");
            Thread.sleep(1000);
            System.out.println(this.name + "获得镜子的锁");
        } else {
            System.out.println(this.name + "获得镜子的锁");
            Thread.sleep(2000);
            System.out.println(this.name + "获得口红的锁");
        }
    }
}

Lock锁（可重入锁）

显示定义同步锁对象实现同步。JUC包下的lock接口时控制多个线程对共享资源进行访问的工具。锁提供了对共享资源的独占访问，每次只能有一个线程对lock对象加锁，线程开始访问共享资源之前应先获得lock对象。

ReentrantLock类实现了Lock它拥有与synchronized相同的并发性和内存语义，在实现线程安全的控制中，比较常用的是ReentrantLock，可以显示加锁，释放锁。

synchronized 与 Lock的对比：

  • Lock是显示锁（手动开启和关闭锁），synchronized是隐式锁，出了作用域自动释放。
  • Lock只有代码块锁，synchronized有代码块锁和方法锁
  • 使用Lock锁，JVM将花费较少的时间来调度线程，性能更好。并且具有更好的扩展性。

优先使用顺序： Lock > 同步代码块（已经进入了方法体，分配了相应的资源）> 同步方法（在方法体之外）

package syn;

import java.util.concurrent.locks.ReentrantLock;

public class TestLock {
    public static void main(String[] args) {
        Ticket ticket = new Ticket();

        new Thread(ticket).start();
        new Thread(ticket).start();
        new Thread(ticket).start();

    }
}

class Ticket implements Runnable {
    int nums = 10;
    private final ReentrantLock lock = new ReentrantLock();

    @Override
    public void run() {
        try {
            //加锁
            lock.lock();
            while (true) {
                if (nums > 0) {
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(nums--);
                } else {
                    break;
                }
            }
        } finally {
            //关闭锁
            lock.unlock();
        }

    }
}
小鱼干换AC
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
多线程学习笔记05线程协作
asdfghjkl_zth的博客
02-01 2599
文章目录多线程学习笔记05线程协作线程通信解决方式1管程法解决方式2信号灯法 多线程学习笔记05线程协作 线程通信 应用场景：生产者和消费者问题 假设仓库中只能存放一件产品，生产者将生产出来的产品放入仓库，消费者将仓库中产品取走消费； 如果仓库中没有产品，则生产者将产品放入仓库，否则停止生产并等待，直到仓库中的产品被消费者取走为止； 如果仓库中放有产品，则消费者可以将产品取走消费，否则停止消费并等待，直到仓库中再次放入产品为止。 我们来分析一下： 首先，这是一个线程同步问题，生产者和消费者共享同一个资
Java多线程学习笔记(七)--线程池
热门推荐
至尊宝
05-19 2万+
什么是线程池 为了避免系统频繁地创建和销毁线程,我们可以让创建的线程进行复用,线程池是来管理线程的,线程池中总有那么几个活跃线程,当使用线程时可以从池子中随便拿一个空闲线程,当完成工作时,不用立即关闭线程,而是将线程还给线程池,方便下一个要使用线程的任务,有了线程池后,创建线程变成是从线程池中拿线程,销毁线程时变成是将线程还给线程池继续管理。 这种场景非常像在开发中连接数据库,有一个数据库连...
Java 多线程学习笔记
2301_76962889的博客
07-13 1866
*进程：**是操作系统进行资源分配和调度的基本单位，是程序的一次执行过程。**例如：**当你打开一个应用程序，如浏览器、音乐播放器等，操作系统就会为其创建一个进程。**线程：**是进程的一个执行单元，是 CPU 调度和分派的基本单位，一个进程可以包含多个线程。**例如：**在浏览器进程中，可以有多个线程同时运行，例如一个线程负责页面渲染，另一个线程负责网络请求。提高 CPU 利用率，充分利用多核处理器**例如：**下载软件使用多线程可以同时下载多个文件片段，充分利用带宽，提高下载速度。
C#多线程学习笔记
wangyunman的博客
08-23 782
C#多线程 1、多线程使用一般方法 Thread t = new Thread(new ThreadStart(Method)); Method为无参函数，若要传递参数，可以将Method的参数设置为object类型。 2、多线程处理List 最近碰到了多线程处理List的问题，开始的想法是开启5个线程，每个线程轮流获取List中的字符串，但是处理完一个字符串就有一个问题，线程无法重用，线程重用可...
Java 多线程学习笔记（狂神）
qq_36188127的博客
11-18 3436
第1章 1.1 什么是线程 栈空间操作起来最快但是栈很小，通常大量的对象都是放在堆空间，栈和堆的大小都可以通过 JVM 的启动参数来进行调整，栈空间用光了会引发 StackOverflowError，而堆和常量池空间不足则会引发 OutOfMemoryError。 String str = new String("hello"); 上面的语句中变量 str 放在栈上，用 new 创建出来的字符串对象放在堆上，而 “hello” 这个字面量是放在方法区的。 1.2 线程的创建与运行 1.2.1 继承 T
多线程基础学习笔记
旋风小陀螺
03-12 1499
多线程基础学习笔记
Java多线程学习笔记
Mike_ToUp
06-15 710
进程和线程的概念 进程：程序（任务）的执行过程。持有资源（共享内存，共享文件）和线程 线程：系统中最小的执行单元。同一进程中有多个线程。 线程共享进程的资源。 线程的交互：互斥/同步Java语言对线程的支持示意图： Thread常用方法：线程的创建：Thread（String name） / Thread（Runnable target）线程的方法： 启动线程：void start（） 线程休眠
java多线程学习笔记
weach的博客
12-19 908
java多线程
C++多线程学习笔记（一）
m0_63932570的博客
05-04 2128
今天是五月三号，五一放假五天，博主也就给自己放了三天假，去游山玩水，吃美食。今天是第四天了，也该慢慢找回学习的状态啦。所以今天博主也是改变自己最近懒惰的状态，来开始自己学习多线程的基础知识。多线程这部分内容对于java，c++爱好者应该不陌生，经常听到或看到的吧。建议在学完c++基础语言知识后的同学们，还是值得学一下这部分内容的（其实也不算很多内容）。下面我们正式开始来看看吧 1.理解多线程。 多线程并发指的是在同一个进程中执行多个线程。C++11提供了语言层面上的多线程，包含在头文件<threa
JAVA 多线程学习笔记
03-27
这篇学习笔记将深入探讨Java多线程的核心概念、实现方式以及相关工具的使用。 一、多线程基础 1. 线程与进程：在操作系统中，进程是资源分配的基本单位，而线程是程序执行的基本单位。每个进程至少有一个主线程，...
java多线程学习笔记之自定义线程池
08-29
Java多线程学习笔记之自定义线程池 本篇文章主要介绍了Java多线程学习笔记之自定义线程池，通过深入了解ThreadPoolExecutor这个核心类，我们可以自定义线程池，满足不同的线程池需求。 Java多线程学习笔记之自定义...
多线程学习笔记.docx
06-16
在多线程编程中，进程和线程是两个核心概念。进程是操作系统资源分配的基本单位，每个独立执行的程序都对应一个进程。而线程则是程序执行的最小单元，是进程内部的一条执行路径。多线程是指在一个应用程序中存在多个...
多线程 学习笔记.md
05-04
多线程 学习笔记.md
okhttp，retrofit,rxjava 是如何配合工作的 作用分别是什么
追梦的鱼儿
09-04 561
OkHttp、Retrofit 和 RxJava 是 Android 开发中常用的三种库，它们各自有不同的作用，并且可以很好地配合工作来实现网络请求和响应的处理。
JAVA基础：数据类型、命名规范
最新发布
weixin_53755148的博客
09-05 1281
变量类型就是用来指定变量中存储数据的类型。也称为数据类型。
SpringBoot 项目集成 xxl-job
qq_58159506的博客
09-03 707
SpringBoot 项目集成 xxl-job
nmt---Docker-compose自动化部署
qq_69920145的博客
09-03 1027
static-rr 权重, leastconn 最少连接, source 请求IP, 轮询 roundrobin。# 这⾥是容器中的IP地址，由于配置的是轮询roundrobin，weight 权重其实没有⽣效。# 这⾥是容器中的IP地址，由于配置的是轮询roundrobin，weight 权重其实没有⽣效。# 在 mysql 创建⼀个没有权限的haproxy⽤户，密码为空。# 在 mysql 创建⼀个没有权限的haproxy⽤户，密码为空。10. docker-compose移除容器。
多线程学习笔记：概念与初步实践
"关于多线程学习总结" 在计算机科学中，多线程是并发执行的编程模型，允许程序在同一时间处理多个任务。这种技术尤其在需要优化资源利用和提高响应速度的应用中至关重要。多线程使得程序员能够在一个进程中创建多个...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值