JAVA基础知识回顾-----多线程基础-----随想随写

最新推荐文章于 2022-04-29 14:59:42 发布
最新推荐文章于 2022-04-29 14:59:42 发布
阅读量310 收藏
点赞数
文章标签： 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hangge110/article/details/51614410
版权

 下载 经常会有人问你，什么是进程，什么是线程，进程和线程有什么关系
（区别），所以我觉得还是有必要总结一下的，虽然可能不太好；
1.定义：所谓进程，就是正在进行的程序，每一个进程都有自己独立的一块
内存空间，比如在Windows系统下，一个EXE就是一个进程，可以在任务管理下
查看你运行的所有进程，而针对于此，线程指的是进程中的一个执行流程，
一个进程可以包含多个线程，多个线程共享一片内存空间；
2.线程实现的方式：
  a) 继承Thread类，复写run方法（放置需要采用多线程技术的代码），建立对象
     对象通过start启动多线程
     ep1：
     完整代码：

Java代码   收藏代码
  1.      package com.ahuiby.test;  
  2.   
  3. class Dog extends Thread{  
  4.  public Dog(){}  
  5.   
  6.  @Override  
  7.  public void run() {  
  8.   // TODO Auto-generated method stub  
  9.   for(int i=0;i<5;i++){  
  10.    System.out.println(Thread.currentThread().getName()+": "+i);  
  11.   }  
  12.  }  
  13.    
  14. }  
  15. public class Test {  
  16.   
  17.  public static void main(String[] args) {  
  18.   // TODO Auto-generated method stub  
  19.   Dog d1=new Dog();  
  20.   Dog d2=new Dog();  
  21.     
  22.   d1.start();  
  23.   d2.start();  
  24.  }  
  25.   
  26. }  

 

    运行结果：

Java代码   收藏代码
  1. Thread-1: 0  
  2. Thread-1: 1  
  3. Thread-0: 0  
  4. Thread-0: 1  
  5. Thread-1: 2  
  6. Thread-0: 2  
  7. Thread-1: 3  
  8. Thread-0: 3  
  9. Thread-1: 4  
  10. Thread-0: 4  

 

  b) 继承Runnable，复写run方法（放置需要采用多线程技术的代码），建立对象，将对象作为Thread的参数创建 下载地址 Thread对象
     通过start启动多线程
ep2:
完整代码：

Java代码   收藏代码
  1. package com.ahuiby.test;  
  2.   
  3. class Dog implements Runnable{  
  4.  public Dog(){}  
  5.   
  6.  @Override  
  7.  public void run() {  
  8.   // TODO Auto-generated method stub  
  9.   for(int i=0;i<5;i++){  
  10.    System.out.println(Thread.currentThread().getName()+": "+i);  
  11.   }  
  12.  }  
  13.    
  14. }  
  15. public class Test {  
  16.   
  17.  public static void main(String[] args) {  
  18.   // TODO Auto-generated method stub  
  19.   Dog d1=new Dog();  
  20.   Thread th1=new Thread(d1);  
  21.   Dog d2=new Dog();  
  22.   Thread th2=new Thread(d2);  
  23.     
  24.   th1.start();  
  25.   th2.start();  
  26.  }  
  27.   
  28. }  

 
运行结果：

Java代码   收藏代码
  1. Thread-1: 0  
  2. Thread-0: 0  
  3. Thread-0: 1  
  4. Thread-0: 2  
  5. Thread-0: 3  
  6. Thread-0: 4  
  7. Thread-1: 1  
  8. Thread-1: 2  
  9. Thread-1: 3  
  10. Thread-1: 4  

 

  c) 继承Thread类和实现Runnable接口区别
     ①：Thread类不能对同一个对象多次启动线程，即这样产生的后果是不能够实现数据共享，但是可以
      通过同步来解决，而Runnable可以对同一个对象进行多次线程启动，可以直接实现数据共享；这与
      他们创建对象的方式有很大关系；
    Thread创建对象的方式：

Java代码   收藏代码
  1. Dog d1=new Dog();  
  2. Dog d2=new Dog();  
  3.   
  4. d1.start();  
  5. d2.start();  

 
    Runnable创建对象的方式：

Java代码   收藏代码
  1.  Dog d1=new Dog();  
  2. Thread th1=new Thread(d1);  
  3. Thread th2=new Thread(d1);  
  4. th1.start();  
  5. th2.start();  

 
     ②Java只支持单继承，如果继承了Thread类，该类不能再继承其他类，这限制了类的可扩展性，所以
       在这一点上Runnable还是优于Thread的；
3.每次运行一个Java程序，至少运行了2个线程，一个是main线程，一个是垃圾收集线程
4.线程状态：创建、就绪、运行、阻塞、结束
  a) 创建：新创建一个线程对象
  b) 就绪：调用start()方法以后，如果CPU处于占用状态，该线程必须等待运行中的线程结束或挂起，此时
         线程的状态被称为挂起；
  c) 运行：当线程获得CPU的使用权之后，该状态被称为运行状态
  d) 阻塞：线程因为各种原因而放弃对CPU的使用，暂时停止运行，此时线程所处的状态被称之为阻塞；
     阻塞三种情况：
     ①：等待阻塞：运行中的线程调用wait()方法后，线程进入阻塞状态；
     ②：同步阻塞：运行的线程在获取对象的同步锁时，若该同步锁被别的线程占用，线程进入阻塞状态；
     ③：其他阻塞：运行的线程执行sleep()或join()方法，或等待用户输入，线程进入阻塞状态；
  e) 结束：线程执行完毕后的状态称之为结束(也叫dead) 下载地址 ;
5.线程调度的优先级别：
  线程有优先级别，优先级别高的更有机会占有CPU；级别在1-10之间
 

Java代码   收藏代码
  1. MAX_PRIORITY：10  
  2.  MIN_PRIORITY：1  
  3.  NORMAL_PRIORITY:5  

 
6.Thread类src中常用方法探索：
  a) 类声明：public 
class Thread implements Runnable  从这里
     可以看出Thread类其实也是实现了Runnable接口；也就可以解释
     为什么我们可以通过Runnable接口来实现多线程；
  b) *(预读部分，仅作了解)
    

Java代码   收藏代码
  1. /* Make sure registerNatives is the first thing <clinit> does. */  
  2.     private static native void registerNatives();  
  3.   
  4.     static {  
  5.   
  6.       registerNatives();  
  7.   
  8.    }   

      native：在Java中，用native修饰方法的，表示该方法并不是由Java去完成
     而是由C/C++去完成，生成dll文件，由Java来调用 下载地址   ； 
     registerNatives：这个方法由private修饰，并不会对象直接调用，它是由
     紧跟着的static语句块中调用的；
  c) 字段：
     

Java代码   收藏代码
  1. private char        name[];//线程名  
  2.  private int         priority;//线程优先级别  
  3.  private Runnable target;//即将运行的线程  
  4.  public final static int MIN_PRIORITY = 1;//最小优先级  
  5.  public final static int MAX_PRIORITY = 10;//最大优先级  
  6.  public final static int NORMAL_PRIORITY = 5;//默认优先级  

 
     
  d) 方法：

Java代码   收藏代码
  1.  //对线程名的操作  
  2.  //设置线程名:checkAccess():检查线程名是否安全  
  3.  public final void setName(String name) {  
  4.   
  5.     checkAccess();  
  6.   
  7.     this.name = name.toCharArray();  
  8.   
  9.  }  
  10.  //获取线程名  
  11.  public final String getName() {  
  12.   
  13.      return String.valueOf(name);  
  14.   
  15.  }  
  16.   
  17. //对线程的优先级别的操作  
  18. //设置线程优先级别  
  19. public final void setPriority(int newPriority) {  
  20.   
  21.      ThreadGroup g;  
  22.   
  23.      checkAccess();  
  24.   
  25.      if (newPriority > MAX_PRIORITY || newPriority < MIN_PRIORITY) {  
  26.   
  27.          throw new IllegalArgumentException();  
  28.   
  29.      }  
  30.   
  31.      if((g = getThreadGroup()) != null) {  
  32.   
  33.          if (newPriority > g.getMaxPriority()) {  
  34.   
  35.              newPriority = g.getMaxPriority();  
  36.   
  37.          }  
  38.   
  39.          setPriority0(priority = newPriority);  
  40.   
  41.      }  
  42.   
  43.  }  
  44. //获取线程的优先级别（final修饰的方法可以被重载，但是不能被覆盖）  
  45. public final int getPriority() {  
  46.   
  47.      return priority;  
  48.   
  49.  }  
  50.   
  51.    
  52. //覆盖run方法  
  53.  @Override  
  54.   
  55.  public void run() {  
  56.   
  57.      if (target != null) {  
  58.   
  59.          target.run();  
  60.   
  61.      }  
  62.   
  63.  }  
  64.   
  65. //start方法  
  66.  public synchronized void start(){//具体代码}  
  67.  start被同步锁了，如果其他线程要调用start方法,必须等待当前对象释放锁  
  68.   
  69. /currentThread获得当前线程  
  70.  public static native Thread currentThread();  
  71.   
  72. join方法  
  73.  public final synchronized void join(long millis)  
  74.  throws InterruptedException {  
  75.   
  76.      long base = System.currentTimeMillis();  
  77.   
  78.      long now = 0;  
  79.   
  80.   
  81.      if (millis < 0) {  
  82.   
  83.          throw new IllegalArgumentException("timeout value is negative");  
  84.   
  85.      }  
  86.   
  87.   
  88.      if (millis == 0) {  
  89.   
  90.          while (isAlive()) {  
  91.   
  92.              wait(0);  
  93.   
  94.          }  
  95.   
  96.      } else {  
  97.   
  98.          while (isAlive()) {  
  99.   
  100.              long delay = millis - now;  
  101.   
  102.              if (delay <= 0) {  
  103.   
  104.                  break;  
  105.   
  106.              }  
  107.   
  108.              wait(delay);  
  109.   
  110.              now = System.currentTimeMillis() - base;  
  111.   
  112.          }  
  113.   
  114.      }  
  115.   
  116.  }  

 

 

hangge110
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
多线程的启动和终止（个人学习笔记）
weixin_43125854的博客
06-29 144
启动线程的方式： 1.class extentdsThread然后class.start(); 2.classimplements Runnable,然后交给Thread运行。 Thread 和 Runnable 的区别 public class Thread implements Runnable { /* Make sure registerNatives is the first thing <clinit> does. */ private static ...
Java 并发基础
JILAU_WHO_AM_I_Q234的博客
10-28 805
Java并法基础
3.2 Thread面试必问 硬刚jdk源码
刘滨浩的博客
01-23 1552
3.2 初识线程        线程（thread）是操作系统能够进行运算调度的最小单位。当执行java main方法的时候，jvm就会创建一个线程来执行我们编写的java程序，当执行多线程程序的时候，jvm会创建新的线程来执行该线程执行的代码段。 3.2.1 Java创建和启动线程        创建线程有两种方式，第一种直接new Thread()，重写run()方
为什么start方法才能启动线程,而run不行？
Java6888的博客
08-08 280
我们都知道，一个线程直接对应了一个Thread对象,在刚开始学习线程的时候我们也知道启动线程是通过start()方法,而并非run()方法。 那这是为什么呢？ 如果你熟悉Thread的代码的话,你应该知道在这个类加载的时候会注册一些native方法 public classThreadimplementsRunnable{ /*MakesureregisterNativesisthefirstthing<clinit>does.*/ privates...
深入剖析Java创建多线程的三种方式
骑着蜗牛行天下
06-02 169
​ Java中实现创建多线程的方式有三种：继承Thread类、实现Runnable接口，实现Callable接口。在程序开发中只要是多线程，肯定以实现Runnable接口为主，因为runnable接口相比继承Thread类有以下优势： （1）可以避免由Java的单继承特性而带来的局限。 （2）增强程序的健壮性，代码能够被多个线程共享，代码与数据是独立的。 （3）适合多个相同程序代码的线程区处理同一资源的情况。 还是以卖票程序为例，来说明一下： 首先是继承Thread类实现，代码如下： public clas
java基础教程----精华版
09-22
这个"java基础教程----精华版"显然是一份精心整理的资料，旨在帮助初学者快速掌握Java编程的基础知识。下面将详细介绍Java语言的核心概念和关键知识点。 1. **Java语法基础**： - **变量**：在Java中，变量是存储...
Java-语言程序设计线程编程入门PPT.ppt
最新发布
10-31
以下是对Java线程编程基础知识的详细解释： 1. **线程的概念**： - 线程是程序中执行的单一顺序控制流，它是程序的最小执行单元。在Java中，每个线程都包含虚拟的CPU、执行的代码以及处理的数据。 2. **进程与...
Java多线程与线程安全实践-基于Http协议的断点续传
07-06
Java多线程与线程安全实践-基于Http协议的断点续传
WHUT-java多线程实验-第五周-数据库.zip
01-16
WHUT-java多线程实验-第五周-数据库（IDEA实现） 本实验目标在实验 (4) 的基础上实现与本机数据库的连接。即对 DataProcessing 类进行改进，不再使用 Hashtable 存储用户与档案信息，转而使用 JDBC 编程方式实现对...
show-busy-java-threads
10-20
上传到 linux线上服务器，执行 chmod -R 777 show-busy-java-threads 执行权限。 ./show-busy-java-threads 查看执行占用cpu偏高的 线程，方便我们排查定位。
多线程- 让程序更高效的运行
dingmei1901的博客
10-12 447
Java Thread 的一些认识： Java是抢占式线程，一个线程就是进程中单一的顺序控制流，单个进程可以拥有多个并发任务，其底层是切分CPU时间，多线程和多任务往往是使用多处理器系统的最合理方式 进程可以看作一个程序或者一个应用；线程是进程中执行的一个任务，多个线程可以共享资源 一个Java 应用从main 方法开始运行，main 运行在一个线程内，也被称为 “主线程”，R...
并发系列（1）之 Thread 详解
weixin_30614109的博客
03-14 508
本文主要结合 java.lang.Thread 源码，梳理 Java 线程的整体脉络； 一、线程概述 对于 Java 中的线程主要是依赖于系统的 API 实现的，这一点可以从 java.lang.Thread；源码中关键的方法都是 native 方法看出，也可以直接查看 OpenJDK 源码看出来，这一点后面还会讲到；对于 JDK1.8 而言，他的 Windows 版和 Linux 版使用的都是 ...
源码看JAVA【十一】Thread
只因有你，在路上。。。
02-28 9539
1、实现接口Runnable 不仅是Thread，实现Runnable的类也可直接通过线程池启动，或者通过Thread的start方法启动 public class Thread implements Runnable { } 2、注册线程 /* Make sure registerNatives is the first thing &lt;clinit&gt; does. ...
Java多线程
大象
08-22 1168
基本概念Java线程的生命周期 新建状态（New）：当线程对象对创建后，即进入了新建状态，如：Thread t = new MyThread(); 就绪状态（Runnable）： 运行状态（Running）：当CPU开始调度处于就绪状态的线程时，此时线程才得以真正执行，即进入到运行状态。就绪状态是进入到运行状态的唯一入口。 阻塞状态（Blocked）：处于运行状态中的线程由于某种原因，暂时放弃对
并发的发展历史
qq_35729915的博客
08-15 171
并发的发展历史 真空管和穿孔打卡 最早的计算机只能解决简单的数学运算问题，比如正弦、余弦等。运行方式：程序员首先把程序写到纸上，然后穿孔成卡片，再把卡片盒带入到专门的输入室。输入室会有专门的操作员将卡片的程序输入到计算机上。计算机运行完当前的任务以后，把计算结果从打印机上进行输出，操作员再把打印出来的结果送入到输出室，程序员就可以从输出室取到结果。然后，操作员再继续从已经送入到输入室的卡片盒中读入...
Java高级-多线程
云上道人的博客
07-31 229
进程基本概念 概念 进程就是程序的一次执行过程，是系统运行程序的基本单位。操作系统在启动每一个应用时，会为每一个应用划分一块独立内存空间称之为进程。进程是操作系统中运行的一个任务（一个应用程序运行在一个进程中），包括由操作系统分配的内存空间，包含一个或多个线程。一个线程不能独立存在，它必须是进程的一部分。 线程基本概念 线程概念 线程与进行相似...
ThreadLocal 源码剖析
weixin_33995481的博客
05-17 67
ThreadLocal是Java语言提供的用于支持线程局部变量的类。所谓的线程局部变量，就是仅仅只能被本线程访问，不能在线程之间进行共享访问的变量(每个线程一个拷贝)。在各个Java web的各种框架中ThreadLocal几乎已经被用烂了，spring中有使用，mybatis中也有使用，hibernate中也有使用，甚至我们写个分页也用ThreadLocal来传递参数......这也从侧面说明了...
面试官：Java 线程如何启动的？
m0_68103752的博客
04-29 574
工作这么久还是不知道Java 线程如何启动的？这道题可能会与不会这一个题并不会让你代码有多牛、有多好，但是你的技术栈深度和广度，决定你的编程职业生涯是否有一条康庄大道。 一、线程启动分析 new Thread(() -> { // todo }).start(); Java 的线程创建和启动非常简单，但如果问一个线程是怎么启动起来的往往并不清楚，甚至不知道为什么启动时是调用start()，而不是调用run()方法呢？ 那么，为了让大家有一个更直观的认知，我们先站在上帝视角。把这段
iOSObjective-C内存管理和多线程编程深度解析
7. **第七章：GCD基础知识** - 对GCD的核心概念如作业（Operation）、队列（Queue）和分发（Dispatch）进行深入剖析，为读者构建高效的多线程应用程序打下坚实基础。 8. **第八章：GCD的实现** - 介绍如何在实际...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值