线程(thread)

最新推荐文章于 2024-07-15 22:27:12 发布
最新推荐文章于 2024-07-15 22:27:12 发布
阅读量173 收藏
点赞数
分类专栏： java 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_56023706/article/details/123809654
版权

声明:以下笔记来源于韩顺平视频https://www.bilibili.com/video/BV1fh411y7R8?p=1，笔记为楼主亲手劳动，劳动不易，转载请标明谢谢。

线程

创建线程的两种方式
  1. 继承Thread类,重写run方法
  2. 实现Runnable接口，重写run方法
  3. 关于为什么调用 .start() 而不是直接调用 .run() 方法，因为如果直接调用.run() 方法就是主线程调用，而不是开启了多线程，主线程会阻塞在.run() 方法处，调用.start()方法，会让jvm机调用 本地 .start0()方法，根据不同的操作系统与CPU，内存，IO等资源开辟新的线程。才能实现多线程。
静态代理模式

  1. 使用到静态代理模式的一个实例就是 子类要用到某个方法，但是没有实现，可以扔给其它实现其接口的父类，帮忙执行

  2. public class StaticProxy_ {
 public static void main(String[] args) {
//        dog.start();
     Dog dog = new Dog();
     Thread thread = new Thread(dog);
     thread.start();
 }
}

class ThreadProxy implements Runnable {//模拟代理模式

 private Runnable target = null;

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

 public ThreadProxy(Runnable target) {//其实是上转型对象
     this.target = target;
 }
}

class Animal {}

class Dog extends Animal implements Runnable{

 @Override
 public void run() {

 }
}
继承 Thread 与实现 Runnable 的区别
  1. 从java的设计来看，通过继承Thread或者实现Runnable接口来创建线程本质上没有区别,从jdk帮助文档我们可以看到Thread类本身就实现了Runnable接口
  2. 实现Runnable接口方式更加适合多个线程共享一个资源的情况，并且避免了单继承的限制
  3. 建议使用 Runnable 接口
多线程售票问题
public class SellTicket {
 public static void main(String[] args) {

     /*SellTicket01 sellTicket01 = new SellTicket01();
     SellTicket01 sellTicket02 = new SellTicket01();
     SellTicket01 sellTicket03 = new SellTicket01();

     sellTicket01.start();
     sellTicket02.start();
     sellTicket03.start();*/

     SellTicket02 sellTicket02 = new SellTicket02();
     new Thread(sellTicket02).start();
     new Thread(sellTicket02).start();
     new Thread(sellTicket02).start();
 }
}
class SellTicket01 extends Thread {

 public static int ticketNum = 100;
 @Override
 public void run() {
     while (true) {
         if (ticketNum <= 0) {
             System.out.println("售票结束~~");
             break;
         }
         try {
             Thread.sleep(50);
         } catch (InterruptedException e) {
             e.printStackTrace();
         }
         System.out.println("窗口 " + Thread.currentThread().getName() + "售出" + --ticketNum + "张票~");
     }
 }
}

class SellTicket02 implements Runnable{

 public int ticketNum = 100;
 @Override
 public void run() {
     while (true) {
         if (ticketNum <= 0) {
             System.out.println("售票结束~~");
             break;
         }
         try {
             Thread.sleep(50);
         } catch (InterruptedException e) {
             e.printStackTrace();
         }
         System.out.println("窗口 " + Thread.currentThread().getName() + "售出" + --ticketNum + "张票~");
     }
 }
}
控制线程退出

  1. 当线程完成任务后，会自动退出。

  2. 还可以通过使用变量来控制run方法退出的方式停止线程，即通知方式

  3. public class TreadExit_ {
 public static void main(String[] args) throws InterruptedException {
     T t = new T();
     t.start();
     Thread.sleep(10 * 1000);
     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;
 }
}
线程常用方法

  1. setName //设置线程名称，使之与参数name相同

  2. getName //返回该线程的名称

  3. start //使该线程开始执行; Java虚拟机底层调用该线程的startO方法

  4. run //调用线程对象 run方法;

  5. setPriority //更改线程的优先级

  6. getPriority //获取线程的优先级

  7. sleep//在指定的毫秒数内让当前正在执行的线程休眠(暂停执行)

  8. interrupt //中断线程

  9. yield:线程的礼让。让出cpu, 让其他线程执行，但礼让的时间不确定，所以也不一定礼让成功,如果CPU资源充足，几乎不会礼让成功。

  10. join:线程的插队。插队的线程旦插队成功， 则肯定先执行完插入的线程所有的任务

    • 案例:创建-个子线程,每隔1s输出hello,输出20次，主线程每隔1秒，输出hi ,输出20次.要求:两个线
      程同时执行，当主线程输出5次后，就让子线程运行完毕，主线程再继续。

    • public class ThreadMethod02_ {
 public static void main(String[] args) throws InterruptedException {
     T2 t2 = new T2();
     t2.start();
     for (int i = 1; i <= 20; i++) {
         Thread.sleep(1000);
         if (i == 5) {
             System.out.println("主线程让子线程先吃包子");
//                t2.join();//插队
             Thread.yield();//礼让
             System.out.println("主线程继续吃包子");
         }
         System.out.println("主线程吃了" + i + "个包子");
     }
 }
}

class T2 extends Thread {
 @Override
 public void run() {
     for (int i = 1; i <= 20; i++) {
         try {
             Thread.sleep(1000);
         } catch (InterruptedException e) {
             e.printStackTrace();
         }
         System.out.println("子线程吃了" + i + "个包子");
     }
 }
}
用户线程与守护线程

  1. 用户线程:也叫工作线程，当线程的任务执行完或通知方式结束

  2. 守护线程:一般是为工作线程服务的，当所有的用户线程结束，守护线程自动结束

  3. 常见的守护线程:垃圾回收机制

  4. 设置守护进程 .setDaemon()

  5. public class ThreadMethod03_ {
 public static void main(String[] args) throws InterruptedException {
     MyDaemonThread myDaemonThread = new MyDaemonThread();
     myDaemonThread.setDaemon(true);
     myDaemonThread.start();
     for (int i = 0; i < 10; i++) {
         System.out.println("强在辛苦的工作" + i);
         Thread.sleep(1000);
     }
 }
}
class MyDaemonThread extends Thread {
 @Override
 public void run() {
     for (;;) {
         try {
             Thread.sleep(1000);
         } catch (InterruptedException e) {
             e.printStackTrace();
         }
         System.out.println("宋和马在疯狂聊天");
     }
 }
}
线程的状态 (线程的声明周期)
  • NEW尚未启动的线程处于此状态。
  • RUNNABLE在Java虚拟机中执行的线程处于此状态。
  • BLOCKED被阻塞等待监视器锁定的线程处于此状态。
  • WAITING正在等待另一个线程执行特定动作的线程处于此状态。
  • TIMED_WAITING正在等待另一个线程执行动作达到指定等待时间的线程处于此状态。
  • TERMINATED已退出的线程处于此状态。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-vzDqYxZ1-1648481367329)(D:/Typora%20Data/Img/image-20220313163745510.png)]

  • public class ThreadState_ {
 public static void main(String[] args) throws InterruptedException {
     T t = new T();
     System.out.println(t.getName() + " 的状态为 " + t.getState());
     t.start();
     while(t.getState() != Thread.State.TERMINATED) {
         System.out.println(t.getName() + " 的状态为 " + t.getState());
         Thread.sleep(1000);
     }

     System.out.println(t.getName() + " 的状态为 " + t.getState());
 }
}

class T extends Thread {
 @Override
 public void run() {
     while (true) {
         for (int i = 0; i < 10; i++) {
             System.out.println("hi " + i);
             try {
                 Thread.sleep(1000);
             } catch (InterruptedException e) {
                 e.printStackTrace();
             }
         }
         break;
     }
 }
}
线程同步机制 Synchronized
  1. 在多线程编程，-些敏感数据不允许被多个线程同时访问，此时就使用同步访问技术，保证数据在任何时刻，最多有一个线程访问，以保证数据的完整性。
  2. 也可以这里理解:线程同步，即当有一个线程在对内存进行操作时，其他线程都不可以对这个内存地址进行操作，直到该线程完成操作，其他线程才能对该内存地址进行操作.
互斥锁

  1. JAVA语言中，引入了对象互斥锁的概念，来保证共享数据操作的完整性.

  2. 每个对象都对应于一个可称为“互斥锁”的标记，这个标记用来保证在任一时刻，只能有一个线程访问该对象.

  3. 关键字同步来与对象的互斥锁联系.当某个对象用同步修饰时表明该对象在任一时刻只能由一个线程访问

  4. 同步的局限性:导致程序的执行效率要降低

  5. 同步方法(非静态的)的锁可以是this，也可以是其他对象(要求是同一个对象)

  6. 同步方法(静态的)的锁为当前类本身. 类.class

  7. 注意事项与细节

    1. 同步方法如果没有使用static修饰:默认锁对象为this

    2. 如果方法使用static修饰，默认锁对象:当前类.class

    3. Synchronized (this) 是非公平锁

    4. 实现的落地步骤:

      • 需要先分析。上锁的代码

      • 选择同步代码 块或同步方法

      • 要求多个线程的锁对象为同个即可!

      • SellTicket01 sellTicket01 = new SellTicket01();//继承Thread类的不同对象
SellTicket01 sellTicket02 = new SellTicket01();
SellTicket01 sellTicket03 = new SellTicket01();

sellTicket01.start();
sellTicket02.start();
sellTicket03.start();

        SellTicket03 sellTicket03 = new SellTicket03();//实现Runnable接口的同一对象
new Thread(sellTicket03).start();
new Thread(sellTicket03).start();
new Thread(sellTicket03).start();

  8. class SellTicket03 implements Runnable{
 private boolean loop = true;
 Object object= new Object();

 public static void m2(){
     synchronized (SellTicket03.class) {//this 会报错 cannot be referenced from a static context
         System.out.println("这里不可以填this");
     }
 }

 public /*synchronized*/ void sell() {
     synchronized ( /*this*/ object) {//对象锁 非静态的锁可以是加在不同的对象上
         if (ticketNum <= 0) {
             System.out.println("售票结束~~");
             loop = false;
             return;
         }
         try {
             Thread.sleep(50);
         } catch (InterruptedException e) {
             e.printStackTrace();
         }
         System.out.println("窗口 " + Thread.currentThread().getName() + "售出" + --ticketNum + "张票~");
     }
 }

 public int ticketNum = 100;
 @Override
 public void run() {
     while (loop) {
         sell();
     }
 }
}
释放锁

以下情况会释放锁

  1. 当前线程的同步方法、同步代码块执行结束
  2. 当前线程在同步代码块、同步方法中遇到break、return。
  3. 当前线程在同步代码块、同步方法中出现了未处理的Error或Exception,导致异常结束
  4. 当前线程在同步代码块、同步方法中执行了线程对象的wait()方法，当前线程暂停，并释放锁。

以下情况不会释放锁

  1. 线程执行同步代码块或同步方法时，程序调用Thread.sleep()、Thread.yield()方法暂停当前线程的执行，不会释放锁
  2. 线程执行同步代码块时，其他线程调用了该线程的suspend()方法将该线程挂起，该线程不会释放锁。
    提示:应尽量避免使用suspend(和resume()来控制线程，方法不再推荐使用
编程题

  1. 有2个用户分别从同一个卡上取钱(总额: 10000)

  2. 每次都取1000,当余额不足时，就不能取款了

  3. 不能出现超取现象=》线程同步问题.

  4. public class HomeWork02 {
 public static void main(String[] args) {
     T t = new T();
     Thread thread = new Thread(t);
     thread.setName("t1");
     Thread thread2 = new Thread(t);
     thread2.setName("t2");
     thread.start();
     thread2.start();
 }

}

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

 @Override
 public void run() {
     while (true) {
         synchronized (this) {
             if (money <= 0) {
                 System.out.println("余额不足~~");
                 break;
             }
             money -= 1000;
             System.out.println(Thread.currentThread().getName() + "取走了1000，当前余额为" + money);

         }

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

     System.out.println(Thread.currentThread().getName() + "线程退出~~");
 }
}
何患现在@何惧将来
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
c语言线程的创建步骤,C语言创建线程thread_create()的方法
weixin_36349685的博客
05-18 6292
在头文件 threads.h 中，定义和声明了支持多线程的宏、类型和函数。所有直接与线程相关的标识符，均以前缀 thrd_ 作为开头。例如，thrd_t 是一个对象类型，它标识了一个线程。函数 thrd_create()用于创建并开始执行一个新线程。函数 thrd_create()的其中一个参数为在新线程中需要被执行的函数 thrd_create()的其中一个参数为在新线程中需要被执行的函数。th...
c#线程Thread示例
09-04
C#线程Thread示例 C#作为一门支持多线程的语言，线程的使用是非常常见的。在.NET中，线程的知识虽然不太常被讨论，但是关于线程的知识点还是需要被关注的。本文主要介绍了C#线程Thread示例，包括线程的基本操作、...
c++线程thread教程
性感的小君君
03-16 5442
c++线程thread C++11/C++14 线程教程 thread类官网详解 thread类官网详解 参考链接 文章目录c++线程thread1.创建线程2.守护线程3. 可调用对象4. 传参5. 线程的移动和复制6.线程id7. 互斥mutex 1.创建线程 直接初始话thread类对象进行创建线程，创建线程后调用join()方法，让主线程等待子线程完成工程。 #include <iostream> #include <thread> void thread_func
Android 线程Thread的释放
02-12 9392
线程的控制一直是一个头疼的问题，控制不好的话，内存占用特别的厉害，那么有什么方法能让没有用的线程释放掉呢？ 也许在有点需求中会同时开启几个线程来干某些事，但是在这些事情忙完后，Android自己不会立即将使用完的垃圾迅速回收掉，也就是说，咱们new一个线程，就会多出一份垃圾，一个两个的无关紧要，太多了或者设备性能不好时，问题还是会出现的。Thread的控制，还是咱们自己控制的好。 下面是现在我
c++多线程 thread mutex 使用小结
杂七杂八
11-11 9130
c++多线程 thread mutex 使用小结std::thread std::mutex 基本使用方法std::thread 用于开启一个线程。std::mutex 是互斥锁，防止不同线程间的代码在不同线程间做不安全的切换std::mutex try_lock()子线程作生产者、主线程做消费者子线程做加载、主线程显示百分比多线程里遇到的几个问题： c++对于多线程的支持，依赖于 std::th...
C++ thread线程函数返回值
Keivin
03-13 6333
int f2(double p ,double& nn,int& n,int& bb) { int test = 3; for (int i = 0; i < 5; ++i) { std::cout << "Thread 2 executing\n"; //std::this_thread::sleep_for(std::chrono::milliseconds(10)); } bb = test; return bb; } std::.
C++11多线程thread参数传递问题
热门推荐
A_Bo的博客
12-31 3万+
目录 写在前面 thread类的构造函数 join函数 detach函数 thread中参数传递 类对象作为参数 类中函数作为参数 参考书籍 写在前面 多线程在很多地方都是必须要掌握的方法，这里先说一下，thread对象的参数传递问题 thread类的构造函数 thread() noexcept; //default constructor 其中noexc...
java 线程 多线程 thread 设置线程名称 获取线程名称
09-25 1万+
java 线程 多线程 thread 设置线程名称 获取线程名称 public class Name extends Thread { @Override public void run() { //setName()方法设置线程名称 this.setName("线程A"); System.out.println("线程名称：" + this.getName()); ...
【多线程基础】 Thread 类的基本用法
书生-w的博客
03-19 2万+
上一篇文章我们讲了Java关于线程的基本知识,接下来给大家分享一些线程是如何创建的以及线程的一些基本用法!
C++多线程之线程类thread
喜欢打篮球的普通人
05-26 4310
文章目录1.简介2.构造函数3.公共成员函数4.join()5.detach()6.joinable()6.operator=7.静态函数8.C线程库 1.简介 C++11 中提供的线程类叫做 std::thread，基于这个类创建一个新的线程非常的简单，只需要提供线程函数或者函数对象即可，并且可以同时指定线程函数的参数 2.构造函数 这个类提供的一些常用 API // ① //构造函数①：默认构造函，构造一个线程对象，在这个线程中不执行任何处理动作 thread() noexcept; // ② /
Java--线程Thread生命周期的几种状态相互转换及常用API方法说明
JustinQin
10-07 2万+
❤️‍大家好，我是贾斯汀，今天主要聊一聊关于线程的瓜！❤️‍ 先来看一下线程这张图线程的几种运行状态之间运行流程： 看不懂没关系，慢慢来学习，往下学习来继续了解一下~ 什么是线程？ 线程是进程的一部分，是程序执行中的一条执行路线； 进程就是指程序在其自身地址空间的一次执行活动，是程序独立运行的基本单位； 一个进程可以包含多条线程，一个条线程对应一个进程中的一条执行路线。 线程的几种创建方式？ 主要由四种方式创建线程 具体每一种创建方式说明及代码实现如下： /** * 创建Thread线
多线程thread
11-06
多线程thread多线程thread多线程thread多线程thread多线程thread
用VC++创建一个线程thread
07-30
用VC++创建一个新线程
python 创建线程 Thread
09-26
python 创建线程 Thread
Android 线程thread的两种实现方法(必看)
08-31
本文将详细讲解Android中线程Thread的两种实现方法，并通过示例代码进行演示。 首先，我们来了解一下Android中实现线程的基本方式： 1. **扩展`java.lang.Thread`类**： 在Android中，我们可以创建一个新类，继承...
《JavaSE》---6.＜基础语法（Java三大程序控制结构）＞
m0_73456341的博客
07-14 833
本篇博客主要讲解Java基础语法中的三大结构，一种顺序结构、两大分支结构i（if-else、swich-case）、四大循环结构（while、do while、fot、foreach）
Spring Security 授权
persistence_PSH的博客
07-14 905
在 loadUserByUsername 方法，在查询数据库用户信息的时候，同时查询出用户的权限，这里以角色名代指权限。在 loadUserByUsername 方法，在查询数据库用户信息的时候，同时查询出用户的权限，这里以角色名代指权限。在 loadUserByUsername 方法，在查询数据库用户信息的时候，同时查询出用户的权限，这里以角色名代指权限。通过 RBAC 获取到用户的具体权限后，再通过 Security 的 用户-权限-资源 来进行权限控制。HttpSecurity 权限配置。
【Go系列】 Sync并发控制
u013379032的博客
07-14 1026
在上一篇文章中，我们介绍了goroutine和channel，理论上，通过channel可以实现并发控制，但是其他语言的开发者可能更习惯一些原子操作的库。当然Go语言也会提供这样的库，所以我们今天了解一下sync库。
day04：Redis和店铺营业状态设置
最新发布
m0_69266818的博客
07-15 835
介绍了Redis命令和用java操作redis还有营业额状态接口的书写
Java多线程ThreadAPI深度解析
"Java多线程Thread API是Java语言中用于处理并发编程的核心API，它提供了创建、控制和管理线程的功能。本文将详细介绍Thread API的使用，包括构造方法、线程名设置、线程组以及Runnable接口的应用。" 在Java中，...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值