Java基础21 多线程线程两种实现方式 锁

已于 2022-10-14 14:02:35 修改
阅读量1k 收藏
点赞数
分类专栏： Java基础篇 文章标签： java 开发语言 后端
于 2022-02-17 20:00:34 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Xs943/article/details/122986968
版权

一、多线程的概念

1.程序 ：一个固定逻辑与数据的集合 就称为程序 例如淘宝 贪吃蛇小游戏
2.CPU: 中央处理器 主要用于协调程序与硬件进行配置的工作
3.并发与并行
1.并发（高并发）
在同一个时间段 执行两个或者多个任务 单核cpu 是进行相互切换 执行某一个任务 切换速度是非常快 很容易误解是同时执行的 其实是交替执行
2.并行
在同一时刻 执行两个或者是多个任务的时候 多核cpu是同时执行多个任务 同时执行 目前的电脑都是使用多核
例子: 可以听歌 敲代码 看视频
在这里插入图片描述
1.进程: 运行在内存中的程序 就是进程
2.线程：单线程 多线程
线程是进程中执行运算的最小单位，也称为轻量级进程
单线程 执行一条通向cpu 的执行的路径 就是单线程
多线程 有多条通向cpu的执行流程 就称为多线程
3.单线程
在这里插入图片描述
4.多线程 迅雷下载小电影（同时下载） 360 安全卫士 杀毒 清理 优化系统
在这里插入图片描述
5.Java中的main方法 主程序 就是单线程 主线程
在这里插入图片描述

二、第一种方式实现多线程（子类继承Thread）

1.步骤
（1）定义一个类 继承Thread
(2) 重写 run方法 ==> 线程执行的操作
（3）实例化这个类对象 创建线程
（4）调用start() 开启线程
2.代码
线程类
getClass()获取当前所属包名+类名，getName()获取属性名/变量名

package day21;

public class MyThread extends Thread{
   @Override
    public void run(){
        //线程执行的操作
        for (int i = 0; i < 100; i++) {
            //getClass()获取当前所属包名+类名，getName()获取属性名/变量名
            System.out.println(getName()+"\t"+i);
            
        }
    }
}

测试类

package day21;

public class Test01 {
    public static void main(String[] args) {
        //实例化线程对象
        MyThread th = new MyThread();
        //开启线程 控制台输出值是 Thread-0	0
        th.start();
        for ( int i=1;i<=100;i++){
            //控制台输出值是 main 1
            System.out.println(Thread.currentThread().getName()+"\t"+ i);

        }
    }
}

三、线程的调度方式

1.线程有两种调度分配方式： 分配时调度 抢占式调度
2.分配时调度：按照固定的时间来分配每个线程执行操作 多个线程执行操作的时间都是固定
3.抢占式调度 线程获取cpu的执行权越大 执行当前线程的优先级越大
任意一个线程抢到cpu的执行权 就执行当前线程的操作 Java中的多线程就是抢占式调度
4.代码

package day21;

public class Test01 {
    public static void main(String[] args) {
        //实例化线程对象
        MyThread th = new MyThread();
        //开启线程 控制台输出值是 Thread-0	0
        th.start();
        for ( int i=1;i<=100;i++){
            //控制台输出值是 main 1
            System.out.println(Thread.currentThread().getName()+"\t"+ i);

        }

       //实例化第二个对象 控制台输出值是 Thread-1	0
        MyThread th1 = new MyThread();
        th1.start();
    }
}

5.原因的分析
在这里插入图片描述
线程谁抢到就执行谁

四、多线程的内存分析（start和run方法区别）

在这里插入图片描述
代码从上到下运行 ，当线程需要调用start()方法时，会新开辟一个栈内存，该方法进这个栈内存运行，每个线程都会开一个单独的栈内存
当线程调用run()方法时，不会新开辟一个栈，而是进main方法的所在栈，相当于普通对象调用方法

五、获取线程的名称

在这里插入图片描述

package day21;

public class Test01 {
    public static void main(String[] args) {
        //实例化线程对象
        MyThread th = new MyThread();
        //开启线程 控制台输出值是 Thread-0	0
        th.start();
        for ( int i=1;i<=100;i++){
            //控制台输出值是 main 1
            System.out.println(Thread.currentThread().getName()+"\t"+ i);

        }

注意点：
默认获取到线程的名称：Thread-XXX ==>序号时从0开始

设置标题的名称

在这里插入图片描述

package day21;

public class MyThread extends Thread{
    //无参构造

    public MyThread() {
    }
    //有参构造
    public MyThread(String name) {
        super(name);
    }

    @Override
    public void run(){
        //线程执行的操作
        for (int i = 0; i < 100; i++) {
            //getClass()获取当前所属包名+类名，getName()获取属性名/变量名
            System.out.println(getName()+"\t"+i);
            //间隔1秒钟来打印即1000毫秒
            /*try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }*/
        }
    }
}


package day21;

public class Test02 {
    public static void main(String[] args) {
        //使用第一种方式 通过setName
        MyThread th1 = new MyThread();
        th1.setName("线程1");
        th1.start();
        //通过第二种方式来进行设置
        MyThread th2 = new MyThread("线程2");
        th2.start();
    }
}

六、线程休眠

在这里插入图片描述

package day21;

public class MyThread extends Thread{
    //无参构造

    public MyThread() {
    }
    //有参构造
    public MyThread(String name) {
        super(name);
    }

    @Override
    public void run(){
        //线程执行的操作
        for (int i = 0; i < 100; i++) {
            //getClass()获取当前所属包名+类名，getName()获取属性名/变量名
            System.out.println(getName()+"\t"+i);
            //间隔1秒钟来打印即1000毫秒
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            }
    }
}

七、守护线程

1.守护线程 也就是为其他线程做铺垫，守护其他线程完成操作 Java中gc 垃圾回收器 Java项目在运行的时候 会出现很多垃圾的对象 这个和守护线程 一致监听着 进行垃圾回收
2.守护线程的死亡
被守护的线程死亡 守护肯定会死亡
被守护的线程的操作的执行完成 守护线程也会随之死亡
一般守护的都是主线程
3.设置守护线程
在这里插入图片描述

package day21;

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

public class MyThread1 extends Thread {
    @Override
    public void run(){

        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        try {
            FileOutputStream fos = new FileOutputStream("1.txt");
            fos.write(97);
            fos.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}


package day21;

public class Test03 {
    public static void main(String[] args) {
        MyThread1 my = new MyThread1();
        //需要将其设置为守护线程  守护的线程就是主的线程
        //一定要再开启线程之前调用 否则没有效果
        my.setDaemon(true);
        System.out.println(my.isDaemon());
        my.start();
    }
}

八、设置线程的优先级

在这里插入图片描述
三个常量
在这里插入图片描述

注意点：
1.设置优先级的值越大 获取cpu的执行权越大 范围 1-10
2.优先级的值越大 并不一定会执行java 抢占式调度
理解 优先级 是更大概率抢到cpu 但概率是概率 不是一定

package day21;

public class Test04 {
    public static void main(String[] args) {
        MyThread th1 = new MyThread();
        th1.setPriority(Thread.MAX_PRIORITY);
        //开启线程
        th1.start();
        MyThread th2 = new MyThread();
        th2.setPriority(8);
        th2.start();
    }
}

九、第二种方式实现多现线程（实现类连接Runnable接口）

步骤
1.定义一个类 这个类需要实现Runnable这个接口
2.实现其抽象方法 run() ==>执行线程操作
3.实例化线程Thread 对象 构造方法参数就是Runnable的实现类
4.开启线程 调用start()方法
注意点：
这一种方式底层也是使用第一种方式来实现了 这种方式就是为了解决线程 java单继承的问题

package day21;

public class MyRunnable implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName()+"\t"+i);
        }
    }
}


package day21;

public class Test05 {
    public static void main(String[] args) {
        MyRunnable runnable = new MyRunnable();
        Thread th =new Thread(runnable);
        th.start();
        Thread th1 = new Thread(runnable);
        th1.start();
    }
}

十、伪第三种方式实现多线程（使用匿名内部类）

1.匿名没有名字 类部类就是定义在类中的类
2.匿名内部类的语法
new 抽象类| 或者是接口{
实现的方法
}
3.代码
new Thread(){public void run() }.start(); 这个是在方法参数后加大括号，在大括号里重写run()，实质是第一种方式的匿名写法
new Thread(new Runnable()）.start(); 这个是在方法参数里new Runnable() 匿名类，在匿名类中重写run()，实质是第二种方式的匿名写法

package day21;

public class Test06 {
    public static void main(String[] args) {
        new Thread(){
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"\t"+"在执行操作");
            }
        }.start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"\t"+"在执行操作");
            }
        }).start();
    }
}

十一、线程之间的通信问题

在这里插入图片描述
1.案例
1.使用三个线程来购买电影票 必须实现接口 这种方式来实现
2.需要定义一个变量来记录其票数
3.使用循环来进行购买 需要判断是否存在票 每次购买完票之后 票数需要-1

public class MyMovieRunnable implements Runnable {
//定义一个变量来记录其总的票数
private int count =100;
@Override
public void run() {
//使用死循环 一直进行购买票
while (true) {
try {
Thread.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
//判断票是否还存在
if (count>0){
System.out.println(Thread.currentThread().getName()+"买了
第"+count+"张票");
// 需要进行递减
count--;
}
}
}
}

package day21;

public class Test07 {
    public static void main(String[] args) {
        MyMovieRunnable movieRunnable = new MyMovieRunnable();
        Thread th1 = new Thread(movieRunnable);
        th1.start();;
        Thread th2 = new Thread(movieRunnable);
        th2.start();
        Thread th3 = new Thread(movieRunnable);
        th3.start();
    }
}

2.出现问题的原因
在这里插入图片描述
3.解决方法一
第一种方式:使用同步代码块
同步就是排队，一个一个来
1.同步代码块的语法:
synchronized (锁的对象){
出现问题的代码
}
2.注意点
(1)锁的对象可以是任意的对象，但要保证多线程数据安全，应该锁多线程共享的数据
(2)所有的线程都必须使用同一个锁的对象
3.作用：
保证多线程数据共享的安全性
4.改造代码

package day21;

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class MyMovieRunnable implements Runnable {
    //定义一个变量来记录其总的票数
    private  int count =100;
   
    //定义一个锁的对象 多线程都共享obj对象
    private Object obj = new Object();
    @Override
    public void run() {
        while (true){

            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            synchronized (obj){
                if(count>0){
                    System.out.println(Thread.currentThread().getName()+"买了第"+count+"张票");
                    //需要递减
                    count--;
                }
            }

        }
    }

4.解决问题的原理
在这里插入图片描述
5.解决问题方法二
1.使用的是同步的方法 可以使用同步的普通方法 也可以使用同步的静态方法
2.同步方法的语法
访问修饰符 synchronized 访问值类型 方法的名称(参数列表) {
可以出现问题的代码
}
3.代码

package day21;

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class MyMovieRunnable implements Runnable {
    //定义一个静态变量来记录其总的票数
    private static int count =100;
    //定义一个锁的对象
    private Object obj = new Object();
    @Override
    public void run() {
        while (true){

            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
          
            //判断票是否存在
            showInfo();

        }
    }

    private synchronized void showInfo() {
        if(count>0){
            System.out.println(Thread.currentThread().getName()+"买了第"+count+"张票");
            //需要递减
            count--;
        }
    }
    private static synchronized void showInfoStatic(){
        if(count>0){
            System.out.println(Thread.currentThread().getName()+"买了第"+count+"张票");
            //需要递减
            count--;
        }
    }

4.注意点
普通方法的锁的对象就是当前对象 就是this
静态方法的 锁对象是当前对象的.class 对象
6.第三种解决方法
1.使用Lock锁对象 Lock 实现提供了比使用synchronized 方法和语句可获得的更广泛的锁定操作
2.常用的实现类 ReentrantLock
3.常用的方法
在这里插入图片描述

package day21;

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class MyMovieRunnable implements Runnable {
    private  int count =100;
    Lock lock =new ReentrantLock();
    @Override
    public void run() {
        while (true){
            lock.lock();
            try {
                Thread.sleep(500);
                if(count>0){
                    System.out.println(Thread.currentThread().getName()+"买了第"+count+"张票");
                    //需要递减
                    count--;
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                lock.unlock();
            }

        }
    }
}

synchronized锁升级的原理

无锁，先偏向锁，在轻量级锁，在重量级锁，性能消耗越来越大，且锁升级顺序不可逆
原理：在锁对象的对象头里面有一个threadid字段，线程在第一次访问的时候threadid 为空，jvm 让其持有偏向锁，并将threadid 设置为其线程id ,再次访问的时候会先判断threadid 是否与其线程id一致，如果一致则可以直接使用此对象，如果不一致，则升级偏向锁为轻量级锁，等待锁对象中，通过自选循环一定次数来获取锁，执行一定次数之后，还未正常获取到要使用的对象，此时就会把锁从轻量级升级为重量级锁，此过程就构成了synchronized锁的升级。
作用：锁升级是为了减低锁带来的性能消耗。在Java6之后优化synchronized 的实现方式，使用了偏向级锁升级为轻量级锁再升级到重量级锁的方式，从而降低了锁带来的性能消耗。

十二、线程的死锁

1.死锁： A线程使用B的锁资源 B线程使用A锁资源 都不进行释放 相互等着 这就是死锁
2.例子：宿舍只有一双拖鞋 A.刘正武 B.康林 == >A B 都要出去买东西
A得到左角的拖鞋 B得到右脚的拖鞋 A B 都霸占锁资源都不释放 所以出现死锁 都不能出去
3.代码
鞋资源

package day21;

public class Shoes {
    public static final String left="left";
    public static final String right="right";
}

张三线程

package day21;

public class ZhangSanRunnable implements Runnable{
    @Override
    public void run() {
        synchronized (Shoes.right){
            System.out.println("张三获取右脚拖鞋");
            /*try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }*/
            synchronized (Shoes.left){
                System.out.println("张三获取左脚拖鞋");
            }
        }
    }
}

李四线程

package day21;

public class LiSiRunnable implements Runnable{
    @Override
    public void run() {
        synchronized (Shoes.left){
            System.out.println("李四获取左脚拖鞋");

            synchronized (Shoes.right){
                System.out.println("李四获取右脚拖鞋");
            }
        }
    }
}

测试类

package day21;

public class Test08 {
    public static void main(String[] args) {
        ZhangSanRunnable zhangSan = new ZhangSanRunnable();
        Thread th1 = new Thread(zhangSan);
        th1.start();
        LiSiRunnable liSi = new LiSiRunnable();
        Thread th2 = new Thread(liSi);
        th2.start();
        //如果线程先抢占cpu通道运行完两只鞋就能运行完
        //a占了b锁资源，b占了a锁资源才会运行不完
    }
}
长河落日猿
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java锁
gqtallhappy的博客
12-28 212
1、synchronized：隐式获取释放锁的方式。 synchronized锁升级：无锁、偏向锁、轻量锁（自旋锁）、重量锁（10次自旋锁后） 2、Lock：主动获取和释放锁，具有可操作性、超时获取锁、等多种特性。 Lock是一个接口，定义了锁的基本操作。Lock接口的实现基本都是通过聚合了一个同步器的子类来完成现场访问控制。 公平锁 / 非公平锁 可重入锁 / 不可重入锁 独享锁 / 共享锁 互斥锁 / 读写锁 乐观锁 / 悲观锁 分段锁 偏向锁 / 轻量级锁 / 重量...
多线程（1）线程创建，等待，结束等接口（Linux）
哈尼的博客
02-26 592
Linux多线程（1）线程接口1. 线程创建-pthread_create1.1原型1.2 参数1.3 返回值1.4 -lpthread2. 线程等待-pthread_join2.1 原型2.2 参数2.3 返回值3. 线程结束-pthread_exit3.1 原型3.2 参数4. 获取当前线程ID-pthread_self5. 线程分离-pthread_detach5.1原型5.2 参数5.3 ...
21. java之多线程
qq_44949002的博客
08-03 247
二、多线程 2.1 多线程的创建方式 1）继承Thread类 2）实现Runable接口 3）实现Callable接口 /** * callable方式创建线程 * 返回值 * * 线程间的通讯（wait/notify） */ public class Test1 { public static void main(String[] args) { // //开启一个子线程 // //继承Thread类 // new Thread(){ //
多线程与并发 - 常见的几种锁的实现方式
简单记录一下。
11-25 1万+
正如其名，它是指对数据修改时持保守态度，认为其他人也会修改数据。因此在操作数据时，会把数据锁住，直到操作完成。悲观锁大多数情况下依靠数据库的锁机制实现，以保证操作最大程度的独占性。如果加锁的时间过长，其他用户长时间无法访问，影响程序的并发访问性，同时这样对数据库性能开销影响也很大，特别是长事务而言，这样的开销往往无法承受。使用悲观锁的时候，我们要注意锁的级别，MySQL innodb 在加锁时，只有明确的指定主键或（索引字段）才会使用 行锁；否则，会执行 表锁，将整个表锁住，此时性能会很差。
Java 多线程 线程8锁（含示例代码）
weixin_55871070的博客
04-17 704
以下内容根据视频https://www.bilibili.com/video/BV1vE411D7KE?p=6学习整理 1.标准访问 class Phone{ public synchronized void sendEmail() throws Exception { System.out.println("**sendEmail"); } public synchronized void sendSMS() throws Exception { ...
Java多线程-对比创建多线程的两种方式
最新发布
01-25
Java多线程编程中，创建线程主要有两种方式：继承`Thread`类和实现`Runnable`接口。这两种方式虽然都能实现多线程，但它们在实际应用中有着不同的特性和适用场景。 首先，我们来看看继承`Thread`类的方式。这种方式...
Java多线程实现的两种方式
08-31
本文将深入探讨Java实现多线程的两种主要方式：继承`Thread`类和实现`Runnable`接口。 1. 继承`Thread`类实现多线程 当你需要创建一个新的线程类并且不与已有的类发生冲突时，可以考虑使用继承`Thread`类的方式。...
Java中有两种实现多线程的方式以及两种方式之间的区别
01-20
Java中有两种实现多线程的... 　Java代码 Java中有两种实现多线程的方式以及两种方式之间的区别 Java中有两种实现多线程的方式以及两种方式之间的区别 　classThreadTestextendsThread{ privateintticket=100; publi
浅谈Java的两种多线程实现方式
08-29
本文将详细探讨Java中创建多线程的两种主要方式：继承`Thread`类和实现`Runnable`接口。 **一、继承Thread类** 1. **方式描述**：当一个类直接继承自`Thread`类时，我们可以覆盖`Thread`类的`run()`方法，将线程...
多线程两种实现方式Java
07-28
你可以通过运行这些示例来更好地理解和学习Java多线程的概念。例如，它可能包含一个继承`Thread`的类，一个实现`Runnable`的类，以及演示如何启动和管理这些线程的主程序。 总结，理解并熟练掌握Java中的多线程实现...
多线程的使用与线程锁的两种实现
05-08
了解更多访问https://blog.csdn.net/qq_37651267/article/details/89978759
C++多线程（二）---- mutex互斥量、lock_guard＜mutex＞、unique_lock＜mutex＞的使用和各种方式加锁的区别(详细解析~~~)
weixin_43978744的博客
05-21 4530
C++多线程（二）---- 多线程资源竞争、std::mutex互斥量、lock_guard、unique_lock的使用和各种方式加锁的区别(详细解析~~~)
JAVA基础-多线程中锁机制
骑牛小道士
11-22 2265
JAVA基础-多线程锁机制
JAVA如何在线程中加锁（四种方法）
热门推荐
weixin_43907440的博客
04-22 2万+
JAVA多线程锁 线程的生命周期 ​ 总共六种状态，可归结为五种，线程的最终是死亡，阻塞不是最终状态，只是一个临时状态。只有调用了start方法，线程才进入就绪阶段。 //新生 ​ NEW, //运行​ RUNNABLE, //阻塞​ BLOCKED, //等待，死死地等​ WAITING, //超时等待​ TIMED_WAITING, //终止​ ...
多线程的两种加锁方式
linchao302的专栏
02-20 2146
多线程的同步锁通过synchronized实现 有俩种方式  一种是在代码块加锁 代码块加锁时可以指定任意类的实例过的对象 即锁在这个对象上（任何对象都有一个锁） 使同一时间内只有一个线程可以访问到代码块中 另外一种就是以synchronized关键字修饰方法 这时加锁的对象就是类本身的实例 即this
13、解决多线程下变量不可见性问题：加锁
Garry
05-29 762
一、前言 多个线程访问共享变量，会出现一个线程修改变量值后，其他线程看不到最新值的情况，但是当我们对使用变量的地方加锁，就可解决这一问题。 二、加锁后的代码 package com.zjl.study.多线程.volatile关键字; /** * Created by zjl 2022/5/29 **/ public class 多线程下变量不可见性问题 { public static void main(String[] args) { // 1、启动子线程，将线程中的flag值改为tr
ThreadLocal
响当当的名字
08-30 283
本篇博客实在自己看了JUC视频及嗷丙的博客后编写。具体的一些地方可能写的不太清晰。详情参考嗷丙知乎 ThreadLocal讲解嗷丙-ThreadLocal 1.用途 一：线程隔离，使一个线程单独享有一个变量，从而不加锁便可以保证线程安全。 如经典场景：格式化日期，要想保证线程安全，第一种方式是加锁，但是若是线程数量多的话，锁竞争会变得很大。第二种便是为每个线程创建一个SimpleDateFormat对象，但是这样的话，若是线程有一千个，就需要创建一千个SimpleDateFormat对象，简单但太粗暴。
多线程 加锁
woruosuifenglang的博客
02-16 1786
dispatch_semaphore是GCD采用线程同步的一种方式，与他相关的共有三个参数: dispatch_semaphore_create dispatch_semaphore_signal dispatch_semaphore_wait dispatch_semaphore_create 创建信号量 dispatch_semaphore_create(long value); 给信号量初始一个值，当传递的值小于0，信号量将初始化失败返回NULL。 dispatch_semaphore_t sem
多线程加锁
qq_37540369的博客
08-19 295
多线程加锁的几种方法 Object o //先创建一个对象 Object o =new Object(); synchronized(o){ 代码块} synchronized (o) { if(tickets>0) { try { Thread.sleep(10); } catch (InterruptedException e) { e.printStackTrace(); } Sys...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值