Java 线程基础

已于 2022-03-25 20:07:33 修改
阅读量182 收藏
点赞数
文章标签： java 代理模式 开发语言
于 2021-12-28 14:15:34 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42411696/article/details/122192249
版权

【韩顺平讲Java】线程 Thread Synchronized 互斥锁 进程 并行 并发 死锁等

01----线程，进程相关概念

  • 进程：进程是指运行中的程序，是程序的一次执行过程。
  • 线程：线程由进程创建，是进程的一个实体，一个进程可以有多个线程
  • 线程也可以创建线程

02----并发，并行

  • 单线程：同一时刻，只允许执行一个线程
  • 多线程：同一时刻，可以执行多个线程
  • 并发：同一时刻，多个任务交替执行，造成一种“貌似同时”的错觉，如单核CPU实现多任务
  • 并行：同一时刻，多个任务同时执行

03----线程的创建方式

  1. 继承Thread类
  2. 实现Runnable接口
  3. 启动多线程必须调用start()方法
//方式一：
public class ThreadTest01 {
    public static void main(String[] args) {
        Cat cat = new Cat();
        cat.start();	//启动多线程必须调用start()方法
    }
}

class Cat extends Thread{
    @Override
    public void run() {
        super.run();	//这里根据要求重写方法体
    }
}

// 方式二：
public class RunnableTest01 {
    public static void main(String[] args) {
        Dog dog = new Dog();
        new Thread(dog).start();	//代理模式：静态代理
    }
}

class Dog implements Runnable{
    @Override
    public void run() {

    }
}

05----为什么调用start()方法？

  • start()调用本地方法(native)方法start0()，真正实现多线程的是start0()方法
  • start()调用start0()方法后，该线程并不一定会立即执行，只是将线程变成了可运行状态，具体什么时候执行取决于CPU，由CPU统一调度

08----多线程售票问题（多个线程操作同一个对象）

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

        Tickets tickets1 = new Tickets();
        Tickets tickets2 = new Tickets();
        Tickets tickets3 = new Tickets();
        tickets1.start();
        tickets2.start();
        tickets3.start();
    }
}

class Tickets extends Thread{
    int numTickets = 20;

    @Override
    public void run() {
        while (true){
            if (numTickets <= 0){
                break;
            }
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            System.out.println(Thread.currentThread().getName()+ "卖出了一张票，剩余：" + (--numTickets));
        }
    }
}

10----线程的方法

  1. interrupt：中断，不是退出
  2. sleep：休眠
  3. start：
  4. yield：礼让，不一定成功
  5. join：插队，插入成功则一直执行到完毕

13----守护线程

  1. 用户线程：也叫工作线程，当线程的任务执行完或者以通知方式结束
  2. 守护线程：一般是为工作线程服务的，当所有用户线程结束，守护线程自动结束，如垃圾回收机制
MyDaemonThread t1 = new MyDaemonThread;	//Daemon:守护

t1.setDaemon(true);
t1.start();

14----线程的7大状态

  1. NEW：新建
  2. RUNNABLE：可运行
    • Ready：就绪
    • Running：运行
  3. BLOCKED：阻塞
  4. WAITING：等待
  5. TIMED_WAITING：超时等待，如sleep
  6. TERMINATED ：终止

15----线程的同步

互斥锁：保证数据的完整性。

synchronized：1. 同步方法， 2. 同步代码块

互斥锁注意事项：

  • // 同步方法（非静态）的锁可以是this，也可以是其他对象（要求是同一个对象）；

  • // 同步方法（静态的）的锁只能是当前类本身；

  • 多个线程的锁必须是同一个。

//------------------同步方法------------------------
/*
 * 多个线程同时操作一个对象
 * 买火车票的例子
 *
 * 发现问题：多个线程操作一个对象，线程不安全，数据紊乱
 * */
public class SellTickets03 implements Runnable{

    int ticketNum = 10;
    boolean loop = true;

    @Override
    public void run() {
        while (loop) {
            sell();
        }
    }

    public synchronized void sell(){
        if (ticketNum<=0){
            loop = false;
            return;
        }
        try {
            Thread.sleep(200);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + " 拿到了第 " + ticketNum-- + " 票");
    }

    public static void main(String[] args) {

        SellTickets03 ticket = new SellTickets03();

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



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

        Tickets02 tickets1 = new Tickets02();

        new Thread(tickets1).start();
        new Thread(tickets1).start();
        new Thread(tickets1).start();

    }
}

//------------------同步代码块------------------------
class Tickets02 implements Runnable{
    private int numTickets = 10;
    boolean loop = true;

    public void sell(){
        synchronized (this){    // 同步方法（非静态）的锁可以是this，也可以是其他对象（要求是同一个对象）；
            // 同步方法（静态的）的锁只能是当前类本身;
            if (numTickets <= 0) {
                loop = false;
                return;
            }
            try {
                Thread.sleep(200);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            System.out.println(Thread.currentThread().getName() + "卖出了一张票，剩余：" + --numTickets);
        }
    }
    @Override
    public void run() {
        while (loop){
            sell();
        }
    }
}

17----线程死锁

多个线程互相抱着对方需要的资源，然后形成僵持

某一个同步块同时拥有”两个以上对象的锁“时，就有可能发生死锁问题，如下：

if(...){
    synchronized (lock1){
        .............
            synchronized (lock2){
            ..........
        }
    }
}else{
    synchronized (lock2){
        .............
            synchronized (lock1){
            ..........
        }
    }    
}

18----释放锁

  • 下面情况会释放锁
    1. 当前线程的同步方法，同步代码块执行结束
    2. 当前线程的同步方法，同步代码块遇到break，return
    3. 当前线程在同步方法，同步代码块中出现了未处理的error或exception，导致异常结束
    4. 当前线程在同步方法，同步代码块中执行了线程对象的wait()方法，当前线程暂停，并释放锁
  • 下面情况不会释放锁
    1. 线程执行同步方法，同步代码块时，程序掉哦用了sleep()方法，yield()方法暂停当前线程的执行，不会释放锁
    2. 线程执行同步代码块，其他线程调用了该线程的suspend()方法将该线程挂起，该线程不会释放锁

19----作业

import java.util.Locale;
import java.util.Scanner;

public class Homework01 {
    /*
    * 在main中启动两个线程
    * 线程a循环随机打印100以内的整数
    * 直到线程b从键盘读入“Q”停止  （因此，b得有a的对象）
    * */

    public static void main(String[] args) {
        A a = new A();
        B b = new B(a);
        a.start();
        b.start();

    }
}

class A extends Thread{

    boolean loop = true;

    @Override
    public void run() {
        while (loop){
            System.out.println((int)(Math.random()*100+1));
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println("线程a已推出");
    }

    public void setLoop(boolean loop) {
        this.loop = loop;
    }
}

class B extends Thread{
    A a;
    Scanner scanner = new Scanner(System.in);

    public B(A a) {
        this.a = a;
    }

    @Override
    public void run() {
        //System.out.println("线程b已开启，输入Q停止线性a：");
        while (true){
            System.out.println("线程b已开启，输入Q停止线性a：");

            if (scanner.next().toUpperCase().charAt(0) == 'Q'){
                a.setLoop(false);
                System.out.println("线程b已退出");
                break;
            }
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

作业二：

public class Homework02 {
    /*
    * 有两个用户在同一个卡上取钱（总额：1w）
    * 每次都取1000，当余额不足时，就不能再取款
    * 线程同步问题
    * 多个线程共享资源，优先选取Runnable方式
    * */

    public static void main(String[] args) {

        T t = new T();
        Thread t1 = new Thread(t);
        Thread t2 = new Thread(t);
        t1.setName("Xiaoming");
        t2.setName("Dazhuang");
        t1.start();
        t2.start();
    }
}

class T implements Runnable{

    private int money = 10000;

    @Override
    public void run() {
        while (true) {
            synchronized (this){	// 加锁
                if (money <= 0) {
                    break;
                }
                money = money - 1000;
                System.out.println(Thread.currentThread().getName() + "取走了1000元，现在余额为：" + money);
                try {
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}
「已注销」
关注
韩顺平Java学习笔记_线程专题(基础)
m0_62661440的博客
03-11 500
韩顺平Java学习笔记_多线程基础专题
java线程基础
12-21
Java线程基础是Java编程中不可或缺的一部分，尤其在开发高并发和实时响应的应用时更为重要。线程允许程序同时执行多个任务，提高了程序的效率和响应速度。 **应用程序与进程** 应用程序是用户可以执行的软件实例，...
java线程基础（韩顺平）
fangshyv的博客
12-07 241
1.程序指的是代码，静态 2.进程是一个程序的执行过程 3.线程是由线程创建的，是进程的一个实体，一个进程可以拥有多个线程 举例：一个迅雷的多个下载任务，一个qq的多个聊天窗口 4.并发：宏观并行，微观串行 并行：多个同时，多核cpu可以1.继承Thread类，重写run方法 2.直接绕过Thread类，实现Runnable接口，重写run方法 一个类继承Thread类（或实现Runnable接口），重写run方法，写上自己的业务代码，就成为了线程。 在主函数里，调用这个对象的start方法（相当于调run
【韩顺平】Java线程（基础）知识点总结
m0_66908465的博客
03-16 1951
此篇文章总结自韩顺平老师所讲解的Java线程内容，我将会在引用韩老师原文的基础上增加自己的一些解读，以加深各位小伙伴对于Java线程的理解。希望能为各位学习Java的小伙伴带来帮助。
韩顺平 java 第38讲 线程
chen
10-12 1199
进程、线程的基本概念进程是指运行中的应用程序，每个进程都有自己独立的地址空间（内存空间）。比如用户点击ie浏览器，就启动了一个进程，操作系统就会为该进程分配独立的地址空间，当用户再次点击ie浏览器图标，就又启动了一个进程，操作系统将为新的进程分配新的独立的地址空间。线程是进程中的一个实体，是被系统独立调度和分派的基本单位，线程自己不拥有系统资源，只拥有一点在运行中必不可少的资源，但它可与同属一个进程
韩顺平 java 第40讲 线程同步
chen
10-13 848
线程深入理解 线程对象只能启动一个线程。不管是继承Thread，还是通过实现Runnable接口创建线程，它们的一个对象只能启动（即start()）一次，否则就会有异常抛出。不能通过此方式实现多个线程跑起来。 两种创建线程方法的区别？ 问题：模拟一个机票售票系统，有三个售票点，在一天内卖出2000张票，（一共卖出2000张）。 这里要考虑，多线程并发会带来线程安全问题。本题中，有可能会出现同一张
Java 线程 基础知识总结
Zhangguohao666的博客
07-27 6332
文章目录线程基础生产消费者模型，synchronizedjoin方法+死锁（哲学家进餐问题）join和锁死锁有趣的Timer类Timer多线程的一个运行实例 初步认识下线程，线程怎么去实现（通过继承Thread或者实现Runnable接口） 线程基础 很不严谨的说，线程是什么？线程就是为了让很多个东东并发执行，大大的提高程序执行的效率啊 三个非常重要的概念： 程序：一组写好了的静态代码块（就我...
Java线程基础
Java框架、并发编程、分布式、微服务、Redis、HarmonyOS、中间件等技术
06-14 2512
简介： 线程是操作系统调度的最小单元，在多核环境中，多个线程能同时执行，如果运用得当，能显著的提升程序的性能。 ​ 一、线程初步认识 1、什么是线程 操作系统运行一个程序会为其启动一个进程。例如，启动一个Java程序会创建一个Java进程。现代操作系统调度的最小单元是线程，线程也称为轻量级进程（Light Weight Process），一个进程中可以创建一个到多个线程，线程拥有自己的计数器、堆栈和局部变量等属性，并且能访问共享的内存变量。处理器会通过快速切换这些线程，来执行程序。 ​ 2、Java本身就是
Java基础：Java线程基础
TuT
04-17 3273
操作系统中线程和进程的概念 现在的操作系统是多任务操作系统。多线程是实现多任务的一种方式。 进程是指一个内存中运行的应用程序，每个进程都有自己独立的一块内存空间，一个进程中可以启动多个线程。比如在Windows系统中，一个运行的exe就是一个进程。 线程是指进程中的一个执行流程，一个进程中可以运行多个线程。比如java.exe进程中可以运行很多线程。线程总是属于某个进程，进程中的多个线程共享进程的...
Java线程基础教程完整版
03-14
通过深入学习和实践这些Java线程基础知识，你可以有效地编写出高效、安全的多线程程序。记住，理解线程的原理和掌握同步机制是关键，这将有助于解决复杂的并发问题。阅读"Java线程.pdf"文档，你将获得更详细、全面的...
java-thread：Java线程基础信息
02-07
Java线程基础信息 java线程操作机制 java线程运行机制 通过芯片的速度越来越快，散热也越来越困难。很久都没有看到CPU的原始速度有重大提升了。但我们仍然看到摩尔定律在起作用，CPU的设计者们继续在向每片硅晶上...
HashMap为什么线程不安全？
最新发布
rnnf_yyds的博客
11-03 127
HashMap底层是基于数组 + 链表（在 Java 8 以后，当链表长度超过一定阈值时会转换为红黑树）的数据结构。在多线程环境下，当多个线程同时对HashMap进行put操作时，可下面这种情况：假设两个线程 A 和 B 同时执行put操作，它们计算出的插入位置相同（假设为index线程 A 先获取到了当前index位置的节点，在它还没来得及将新节点插入链表（或树）时，线程 B 也获取到了这个位置的节点。
[自用，更新自day5]瑞吉外卖代码及笔记
lapiii的博客
11-01 809
当使用ThreadLocal维护变量时，ThreadLocal为每个使用该变量的线程提供独立的变量副本，所以每一个线程都可以独立地改变自己的副本，而不会影响其它线程所对应的副本。Mybatis Plus公共字段自动填充，也就是在插入或者更新的时候为指定字段赋予指定的值，使用它的好处就是可以统一对这些字段进行处理，避免了重复代码。因为在分页查询的Dish的records(菜品记录中)，只有这个菜品所属的categoryId，但是我们需要分页的时候展示的是菜品名字。
JAVA 插入 JSON 对象到 PostgreSQL
qq_52143611的博客
10-30 863
在现代软件开发中，由于 JSON 数据的轻量和通用性，处理 JSON 数据已经变得无处不在。PostgreSQL凭借其对 JSON 的强大支持，为存储和查询 JSON 数据提供了出色的平台。为了将JSON数据保存到PostgreSQL数据库中，我们可以将JSON数据转换为PostgreSQL的JSONB类型数据，然后将其存储在数据库中。在Java中，我们可以使用JDBC或者基于ORM框架的方式来实现这一功能。
SpringSession源码分析
lkr_lkr的博客
11-01 249
默认对常规Session的理解和使用，如何使用Set-Cookie。
函数式接口与回调函数实践
m0_37635053的博客
10-29 407
函数式接口与回调函数
Android 13 解决 Settings 首页矢量图修改颜色不生效
人生只是一种体验，不必用来演绎完美。
10-30 283
从Android 12 开始, 推出了Material You 设计，并在 Android 13 中得到了改进。导致了修改svg颜色不生效的问题。
Java复习24（PTA)
2301_79272475的博客
10-30 407
Java复习24（PTA)：多种排序的book类*
Java线程基础与实战
本教程针对已有一定Java基础但对线程处理不太熟悉的开发者，旨在深入讲解Java线程的各个方面。 线程是程序中的执行单元，它们在一个进程中并行运行，每个线程都有自己的程序计数器、堆栈和局部变量，但共享同一内存...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值