韩顺平Java学习笔记_线程专题(基础)

最新推荐文章于 2023-11-23 08:46:16 发布
最新推荐文章于 2023-11-23 08:46:16 发布
阅读量406 收藏 5
点赞数 1
分类专栏： Java学习 文章标签： java 学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_62661440/article/details/129390900
版权

目录

一 线程介绍

1 线程相关概念

二 线程使用

1 创建线程的两种方式

类图:

案例一_实现Thread接口:

​编辑 案例二_实现Runnable接口

2 线程的基本使用

三 线程方法

1 线程终止

2 常用方法 

 3 用户线程和守护线程

四 线程生命周期

五 Sychronized

1.线程同步机制

2. 同步具体方法

3. 案例 

4.同步原理分析 

六 互斥锁

1.基本介绍

 2.注意事项和细节

3.线程的死锁 

4.释放锁 

七 练习题

一 线程介绍

1 线程相关概念

  • 程序
  • 进程
  • 线程: 单线程, 多线程
  • 并发
  • 并行

Runtime runtime = Runtime.getRuntime();
        int i = runtime.availableProcessors();//获取当前电脑的cpu数量
        System.out.println(i);

二 线程使用

1 创建线程的两种方式

1. 继承Thread类,重写run方法

2. 实现Runnable接口,重写run方法

类图:

案例一_实现Thread接口:

public class Thread01 {
    public static void main(String[] args) throws InterruptedException {
        //创建cat对象,可以当做线程使用
        Cat cat = new Cat();
        cat.start();
        //说明: 当main线程启动一个子线程 Thread-0,主线程不会阻塞,会继续执行
        //这时主线程和子线程是交替执行的
        System.out.println("主线程继续执行" + Thread.currentThread().getName());
        for (int i = 0; i < 60; i++) {
            System.out.println("主线程i=" + i);
            Thread.sleep(1000);
        }
    }
}

//1.当一个类继承了Thread类,该类就可以当线程使用
//2.需要重写run方法( 实现了Runnable接口的run方法)
/*
@Override
    public void run() {
        if (target != null) {
            target.run();
        }
    }
 */
class Cat extends Thread {
    int times = 0;

    @Override
    public void run() {
        while (true) {
            //每隔一秒要输出"喵喵,我是小猫咪"
            System.out.println("喵喵,我是小猫咪" + (++times) + "线程名=" + Thread.currentThread().getName());
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            if (times == 80){
                break; //当times到8,就退出while循环
            }
        }
    }
}

 案例二_实现Runnable接口

public class Thread02 {
    public static void main(String[] args) {
        Dog dog = new Dog();
//        dog.start(); 这里不能调用start()
        Thread thread = new Thread(dog);//创建thread对象,把dog对象(实现了runnable),放入thread
        thread.start();
    }
}
class Dog implements Runnable{
    int count = 0;

    @Override
    public void run() {
        while(true){
        System.out.println("小狗汪汪叫...hi" + (++count) + Thread.currentThread().getName());
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        if (count == 10){
            break;
        }
        }
    }
}

Note: 这里底层使用了设计模式[代理模式] 

代码模拟代理模式,方便理解:

        Tiger tiger = new Tiger();
        ThreadProxy threadProxy = new ThreadProxy(tiger);
        threadProxy.start();


class Animal{}
class Tiger extends Animal implements Runnable{
    @Override
    public void run() {
        System.out.println("老虎嗷嗷叫...");
    }
}

class ThreadProxy implements Runnable{ //把proxy看做Thread

    private Runnable target = null;//属性,类型是Runnable

    @Override
    public void run() {
        if (target != null){
            target.run();
        }
    }

    public ThreadProxy(Runnable target) {
        this.target = target;
    }

    public void start(){
        start0();
    }

    public void start0(){
        run();
    }
}

2 线程的基本使用

建议使用Runnable

//        System.out.println("==使用继承接口方式来售票");
//        SellTicket01 sell01 = new SellTicket01();
//        SellTicket01 sell02 = new SellTicket01();
//        SellTicket01 sell03 = new SellTicket01();
//        sell01.start();
//        sell02.start();
//        sell03.start();

        System.out.println("==使用实现接口方式来售票");
        SellTicket02 sellTicket02 = new SellTicket02();
        new Thread(sellTicket02).start();
        new Thread(sellTicket02).start();
        new Thread(sellTicket02).start();

class SellTicket01 extends Thread{
    private static int ticketNum = 100;//让多个线程共享num

    @Override
    public void run(){
        while(true){
            if (ticketNum <= 0){ //会出现票数超卖现象
                System.out.println("售票结束");
                break;
            }
            //休眠50毫秒,模拟人的休息
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            System.out.println("窗口 " + Thread.currentThread().getName() + "售出一张票"
            + "剩余票数=" + (--ticketNum));
        }
    }
}

class SellTicket02 implements Runnable{
    private int ticketNum = 100;//让多个线程共享num

    @Override
    public void run(){
        while(true){
            if (ticketNum <= 0){ //会出现票数超卖现象
                System.out.println("售票结束");
                break;
            }
            //休眠50毫秒,模拟人的休息
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            System.out.println("窗口 " + Thread.currentThread().getName() + "售出一张票"
                    + "剩余票数=" + (--ticketNum));
        }
    }
}

三 线程方法

1 线程终止

案例:启动线程后中止

public class ThreadExit {
    public static void main(String[] args) throws InterruptedException {
        T t = new T();
        t.start();
        //如果希望主线程可以控制t线程的中止,需要修改loop
        //让主线程休眠10秒,再通知t线程退出
        Thread.sleep(10000);
        t.setLoop(false);
    }
}

class T extends Thread {
    private int count = 0;
    private boolean loop = true;
    @Override
    public void run(){
        while(loop){
            try{
                Thread.sleep(50);
            }catch (InterruptedException e){
                e.printStackTrace();
            }
            System.out.println("T 运行中...." + (++count));
        }
    }

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

2 常用方法 

 


public class ThreadMethod {
    public static void main(String[] args) throws InterruptedException {
        T2 t2 = new T2();
        t2.start();
        for (int i = 1; i<=20; i++){
            Thread.sleep(1000);
            System.out.println("主线程(小弟)吃了" + i + "个包子");
            if (i == 5){
                System.out.println("主线程(小弟)让子线程(老大)先吃");
//                //join,线程插队
//                t2.join();//这里相当于让子线程先执行完毕
                System.out.println("子线程(老大)吃完了,主线程(小弟)接着吃");
                Thread.yield();//礼让,不一定成功
            }
        }
    }
}
class T2 extends Thread {
    @Override
    public void run(){
        for (int i=0; i<=20;i++){
            try{
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("子线程吃了" + i + "个包子");
        }

    }
}

 

public class ThreadPractice {
    public static void main(String[] args) throws InterruptedException {
        T3 t3 = new T3();
        Thread thread = new Thread(t3);
        for (int i = 1; i < 11; i++) {
            Thread.sleep(1000);
            System.out.println("hi" + i);
            if (i == 5){
                thread.start();
                thread.join();
            }
            if (i== 10){
                System.out.println("主线程结束");
            }
        }
    }
}
class T3 implements Runnable{
    @Override
    public void run() {
        for (int i =  1;i < 11; i++){
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            System.out.println("hello" + i);
        }
        System.out.println("子线程结束");
    }
}

 3 用户线程和守护线程

线程名.setDaemon(true) 

四 线程生命周期

NEW: 尚未启动的线程

RUNNABLE:运行的

READY: 准备运行的

BLOCKED: 被阻塞的

WAITING: 等待中

TIMEDWAITING: 等待另一个线程执行动作达到指定等待时间

TERMINATED: 已退出的

 

五 Sychronized

1.线程同步机制

线程同步机制:

1. 在多线程编程,一些敏感数据不允许被多个线程同时访问,此时就用同步访问技术,保证数据在任何同一时刻,最多有一个线程访问,以保证数据的完整性;

2. 这样理解: 线程同步,即当有一个线程在对内存进行操作时,其他线程都不可以对这个内存地址进行操作,直到该线程完成操作,其他线程才能对该内存地址进行操作

2. 同步具体方法

(1) 同步代码块

synchronized (对象){

        //需要被同步的代码

} 

(2) synchronized放在方法声明中,表示整个方法为同步方法

public synchronzed void m (String name){

        //需要被同步的代码

}

3. 案例 

 SellTicket03 sellTicket03 = new SellTicket03();
        new Thread(sellTicket03).start();
        new Thread(sellTicket03).start();
        new Thread(sellTicket03).start();

class SellTicket03 implements Runnable{
    private int ticketNum = 100;//让多个线程共享num
    private boolean loop = true;//控制run方法变量

    public synchronized void sell(){//同步方法,同一时刻只能有一个线程执行run方法
        if (ticketNum <= 0){ //会出现票数超卖现象
            System.out.println("售票结束");
            loop = false;
            return;
        }
        //休眠50毫秒,模拟人的休息
        try {
            Thread.sleep(50);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        System.out.println("窗口 " + Thread.currentThread().getName() + "售出一张票"
                + "剩余票数=" + (--ticketNum));
    }

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

4.同步原理分析 

六 互斥锁

1.基本介绍

 2.注意事项和细节

Note: 这里如果使用继承Thread来创建多线程,那么只能使用静态方法锁类,否则不是同一对象;如果实现Runnable接口,则只能创建一个对象!

3.线程的死锁 

多个线程都占用了对方的锁资源,但不肯相让,导致了死锁,在编程是一定要避免死锁的发生

4.释放锁 

七 练习题

 

思路分析: 

public class Homework01 {
    public static void main(String[] args) {
        Thread01 thread01 = new Thread01();
        new Thread(thread01).start();
        Thread02 thread02 = new Thread02(thread01);
        new Thread(thread02).start();

    }
}

class Thread01 implements Runnable {
    public boolean loop = true;

    public boolean isLoop() {
        return loop;
    }

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

    @Override
    public void run() {
        while (loop) {
            System.out.println((int)(Math.random() * 100 + 1));
            //休眠
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
    }
}

class Thread02 implements Runnable {
    private Thread01 thread01;

    private Scanner scanner = new Scanner(System.in);

    public Thread02(Thread01 thread01) {
        this.thread01 = thread01;
    }

    @Override
    public void run() {
        while (true) {
            System.out.println("请输入你的指令(Q表示退出):");
            char next = scanner.next().toUpperCase().charAt(0);
            if (next == 'Q') {
                //以通知的方式结束01线程
                this.thread01.setLoop(false);
                System.out.println("thread02 线程结束");
                break;
            }
        }
    }
}

 

public class Homework02 {
    public static void main(String[] args) {
        extractMoney extractMoney = new extractMoney();
        new Thread(extractMoney).start();
        new Thread(extractMoney).start();
    }
}

class extractMoney implements Runnable {
    private static int money = 10000;

    @Override
    public void run() {
        while (true) {
            synchronized (this) {
                if (money < 1000) {
                    System.out.println("余额不足");
                    break;
                }
                money = money - 1000;
                System.out.println(Thread.currentThread().getName() + "取走了1000 余额为" + money);
            }
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
    }
}

Note: 只获取到一个线程的 注意锁的位置!!! 

家有大悠咪
关注
  • 1
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
韩顺平_循序渐进学Java零基础【完整笔记】1
08-04
第 1 章 内容介绍11.1 本套 JAVA 课程内容11.1.1 课程的三个阶段11.1.2 关于课程的说明11.1.3 课程特色21.2 JAVA 就业方向
韩顺平java笔记完整版.zip（无笔记，只是代码）
10-10
通过韩顺平老师的Java笔记完整版代码，学习者可以深入理解上述知识点，并通过实践加深对Java编程的理解和掌握。这些代码示例涵盖了广泛的Java应用领域，对于初学者和进阶开发者都是宝贵的资源。
韩顺平 Java集合 自学笔记(Java30天基础)
心向阳光的天域的博客
10-18 3402
Java集合 韩顺平老师 Java基础学习笔记
韩顺平Java笔记（自用1）
qq_44235936的博客
01-09 3151
第2章 Java概述 第3章 变量 第4章 运算符 目录 第2章 Java概述 第3章 变量 第4章 运算符 ...
韩顺平Java学习笔记_IO流专题
m0_62661440的博客
02-21 384
韩顺平io流专题学习笔记
java线程基础（韩顺平）
fangshyv的博客
12-07 221
1.程序指的是代码，静态 2.进程是一个程序的执行过程 3.线程是由线程创建的，是进程的一个实体，一个进程可以拥有多个线程 举例：一个迅雷的多个下载任务，一个qq的多个聊天窗口 4.并发：宏观并行，微观串行 并行：多个同时，多核cpu可以1.继承Thread类，重写run方法 2.直接绕过Thread类，实现Runnable接口，重写run方法 一个类继承Thread类（或实现Runnable接口），重写run方法，写上自己的业务代码，就成为了线程。 在主函数里，调用这个对象的start方法（相当于调run
Java基础（韩顺平版）笔记详
最新发布
04-30
韩顺平版Java基础笔记是一套详尽的Java入门教程，内容包括： Java语言概述和环境搭建 基本数据类型、变量和运算符 控制语句：条件语句和循环语句 数组和字符串处理 面向对象编程：类和对象、继承、封装、多态 异常...
韩顺平_java设计模式笔记
11-07
韩顺平老师的Java设计模式课程通过生活中的实例和Spring框架中的应用，深入浅出地讲解了这些模式。 首先，我们来看一下原型设计模式。原型模式主要用于对象的复制，分为浅拷贝和深拷贝。浅拷贝只复制对象的引用，而...
Java韩顺平【学习笔记】（整合）未完成
weixin_52487106的博客
01-17 312
学习笔记
韩顺平JAVA学习笔记（1）
2301_77038529的博客
11-23 40
创建类的对象 = 类的实例化 = 实例化类面向对象创建类，设计类的成员创建类的对象通过“对象，属性“或”对象，方法“调用对象的结构如果创建了一个类的对个对象，则每个对象都独立的拥有一套类的属性。意味着，如果我们修改一个对象的属性a，则不影响另外一个对象的属性a的值。从结果上看：（继承性）​ 子类继承父类以后，就获取了父类中声明的属性和方法。​ 创建子类对象，在堆空间中，就会加载所有父类中声明的属性。
韩顺平java笔记完整版
09-07
java课件PPT、java基础，适合初次接触java的朋友，可以下载看看，ppt。大家最好还要看视频教程学习，一起对着看就可以。
自学韩顺平java笔记
weixin_43548992的博客
06-11 387
韩顺平java学习笔记
【韩顺平】Java线程（基础）知识点总结
m0_66908465的博客
03-16 1877
此篇文章总结自韩顺平老师所讲解的Java线程内容，我将会在引用韩老师原文的基础上增加自己的一些解读，以加深各位小伙伴对于Java线程的理解。希望能为各位学习Java的小伙伴带来帮助。
韩顺平循序渐进学JAVA系列笔记（持续更新）
SanrenZ的博客
10-12 325
链接：SanrenZZG.github.io
韩顺平Java学习笔记_集合底层源码解读
m0_62661440的博客
03-04 594
Java集合专题源码解读
韩顺平 2021零基础学Java 学习笔记（1）（自用）
热门推荐
weixin_43973189的博客
11-02 4万+
目录第 2 章 Java 概述第 3 章 变量第 4 章 运算符第 5 章 程序控制结构第 6 章 数组、排序和查找第 7 章 面向对象编程(基础部分)第 8 章 面向对象编程(中级部分) 第 2 章 Java 概述 2.1 Java 重要特点 Java 语言是面向对象的(oop) Java 语言是健壮的。Java 的强类型机制、异常处理、垃圾的自动收集等是 Java 程序健壮性的重要保证 Java 语言是跨平台性的。[即: 一个编译好的.class 文件可以在多个系统下运行，这种特性称为跨平台] Jav
韩顺平 java 第38讲 线程
chen
10-12 1171
进程、线程的基本概念进程是指运行中的应用程序，每个进程都有自己独立的地址空间（内存空间）。比如用户点击ie浏览器，就启动了一个进程，操作系统就会为该进程分配独立的地址空间，当用户再次点击ie浏览器图标，就又启动了一个进程，操作系统将为新的进程分配新的独立的地址空间。线程是进程中的一个实体，是被系统独立调度和分派的基本单位，线程自己不拥有系统资源，只拥有一点在运行中必不可少的资源，但它可与同属一个进程
B站韩顺平java学习笔记（十六）-- 多线程基础章节
LW_20180806的博客
04-11 2575
一 线程介绍 1 线程相关概念 （1）程序 是为完成特定任务、用某种语言编写的一组指令的集合（简单说就是写的代码）。 （2）进程 ① 进程是指运行中的程序，比如使用的QQ，就启动了一个进程，操作系统回味该进程分配内存空间。当我们使用迅雷，又启动了一个进程，操作系统将会为迅雷分配新的内存空间。 ② 进程是程序的一次执行过程，或是正在运行的一个程序。是动态过程：有它自身的产生、存在和消亡的过程。 （3）什么是线程 ① 线程是由进程创建的，是进程的一个实体； ② 一个进程可以拥有多...
韩顺平Linux教程学习笔记
liuwkk的博客
07-07 8113
韩顺平Linux教程学习笔记 写在前面 虚拟机 Linux目录结构 远程登录Linux系统 vi和vim编辑器 关机、重启和用户登录注销 用户管理 实用指令 组管理和权限管理 定时任务调度 Linux磁盘分区、挂载 网络配置 进程管理 RPM YUM 搭建JAVAEE环境 安装Tomcat 安装Eclipse 安装mysql Shell编程 Shell编程综合案例 Python定制篇 开发平台Ubuntu 虚拟机.

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值