线程知识点(理解与总结)

最新推荐文章于 2023-04-02 22:05:53 发布
最新推荐文章于 2023-04-02 22:05:53 发布
阅读量240 收藏
点赞数
分类专栏： 线程 Java基础 文章标签： 线程 知识点总结 深入学习理解
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Nostalgia_csdn/article/details/103222149
版权
本文详细介绍了Java线程的基础知识，包括Thread类、线程的创建方式、线程安全问题、线程同步（同步代码块、锁机制）以及线程池的概念和使用。通过实例解析线程的计时等待、锁阻塞和无限等待状态，以及等待唤醒机制。最后，探讨了线程池在多线程环境中的重要性和使用技巧。
摘要由CSDN通过智能技术生成

线程知识点(理解与总结)

进程：指一个内存中运行的应用程序。例如运行QQ那么它就是一个进程，而且一个应用程序可以同时运行多个进程

线程：线程是进程中的一个执行单元，就比如用360我们可以让它一边杀毒一边清理垃圾，那么360它就是一个进程，那么杀毒和清理垃圾就是进程下的两个线程
注：一个程序运行后至少有一个进程，一个进程中可以包含多个线程

Thread类

构造方法：
public Thread() :分配一个新的线程对象。

public Thread(String name) :分配一个指定名字的新的线程对象。

public Thread(Runnable target) :分配一个带有指定目标新的线程对象。

public Thread(Runnable target,String name) :分配一个带有指定目标新的线程对象并指定名字。

常用方法：
public String getName() :获取当前线程名称。

public void start() :导致此线程开始执行; Java虚拟机调用此线程的run方法。

public void run() :此线程要执行的任务在此处定义代码。

public static void sleep(long millis) :使当前正在执行的线程以指定的毫秒数暂停

public static Thread currentThread() :返回对当前正在执行的线程对象的引用。

创建线程的方式总共有两种：
1.是继承Thread类方式
2.是实现Runnable接口

创建线程的方式一：

  1. 定义Thread类子类，并重写该类的run()方法，run()方法的方法体就代表了线程需要完成的任务,
  2. 创建Thread子类的实例3. 调用Thread的start()方法来启动该线程

代码如下：

public class Test {
	public static void main(String[] args) {
		MyThread mt = new MyThread();
		Thread t1 = new Thread(mt);		
		t1.start();	
	}
}
class MyThread extends Thread{
	@Override
	public void run(){
	System.out.println("第一种方式创建线程");	
	}
}

创建线程的方式二：

  1. 定义Runnable接口的实现类，并重写该接口的run()方法，run()方法的方法体代表线程完成的任务
  2. 创建Runnable实现类的实例。
  3. 调用Thread的start()方法来启动线程。

代码如下：

public class Test {
	public static void main(String[] args) {
		MyRunnable mr = new MyRunnable();
		Thread t1 = new Thread(mr);
		t1.start();
	}
}
class MyRunnable implements Runnable{
	@Override
	public void run(){
	System.out.println("第二种方式创建线程");	
	}
}

Thread和Runnable的区别

因为类都是单继承的，如果一个类继承Thread，就不可以继承其他类了。但是如果实现了Runnable接口的话，则很容易的实现资源共享，避免了java中的单继承的局限性，所以Runnable比Thread更有优势

用匿名内部类创建线程

使用匿名内部类的方式实现Runnable接口，重写Runnable接口中的run方法：

代码如下：

public class Test {
	public static void main(String[] args) {
		new Thread(new Runnable(){
			@Override
			public void run() {
				System.out.println("匿名内部类创建线程");
			}
		}).start();
	}
}

线程安全问题的概述

如果有多个线程在同时运行，而这些线程可能会同时运行这段代码。程序每次运行结果和单线程运行的结果是一样的，而且其他的变量的值也和预期的是一样的，就是线程安全的。
那么什么是线程不安全的呢？我们由一段代码看一下：
这里我想打印的是1-100之间的整数：

public class Test {
  public static void main(String[] args) {
   MyRunnable r = new MyRunnable();
   Thread t1 = new Thread(r);
   Thread t2 = new Thread(r);
   Thread t3 = new Thread(r);
   t1.start();
   t2.start();
   t3.start(); 
  }
}
class MyRunnable implements Runnable{
  private int sum = 100;
  public void run(){
   while(true){
    if(sum>0){
     try {
      Thread.sleep(10);
     catch (InterruptedException e) {
      e.printStackTrace();
     }
     System.out.println(sum);
     sum--;
    }
   }
  }
}

运行结果出现了很多重复的，甚至还有-1，结果和预期是不一样的，这就是线程不安全情况。那么为什么会出现这种情况呢？是因为这三个线程在执行过程中不断抢夺CPU的执行权，当某一个线程运行到Thread.sleep(10)的时候处于睡眠状态，那么CPU的执行权交给了另外两个线程以此类推，三个线程都执行到了这里，这时代码就不是一条判断一条输出了，当睡眠结束后三条线程面临的都是一条输出语句一个sum–不再判断sum的值，若最后判断sum的值为1，最后sum的值将被–三次，所以才会导致最终的结果出现0和-1的情况(最终sum的值为-2)，这里的Thread.sleep()其实是为了增加线程安全问题出现的概率。

线程同步

当我们使用多个线程访问同一资源的时候，且多个线程中对资源有写的操作，就容易出现线程安全问题。 要解决上述多线程并发访问一个资源的安全性问题，Java中提供了同步机制(synchronized)来解决。

同步代码块

无论是否失去CPU的执行权，让其他线程只能处于等待状态

格式:

 synchronized(同步锁){ 
	//需要同步操作的代码
}

使用同步代码块解决代码(运行结果准确无误的输出1-100之间的整数)：

public class Test {
  public static void main(String[] args) {
   MyRunnable r = new MyRunnable();
   Thread t1 = new Thread(r);
   Thread t2 = new Thread(r);
   Thread t3 = new Thread(r);
   t1.start();
   t2.start();
  t3.start();
  }
}
class MyRunnable implements Runnable{
  private int sum = 100;
  Object obj = new Object();
  public void run(){
   while(true){
    synchronized(obj){
     if (sum > 0) {
      try {
       Thread.sleep(10);
      } catch (InterruptedException e) {
       e.printStackTrace();
      }
      System.out.println(sum);
      sum--;
     }
    }
   }
  }
}

修饰的方法,就叫做同步方法,保证某一线程执行该方法的时候,其他线程只能在方法外等着。

使用同步方法代码如下：

public class Test {
 public static void main(String[] args) {
   MyRunnable r = new MyRunnable();
   Thread t1 = new Thread(r);
   Thread t2 = new Thread(r);
   Thread t3 = new Thread(r);
   t1.start();
   t2.start();
   t3.start();
 }
}
class MyRunnable implements Runnable {
  private int sum = 100;
  Object obj = new Object();
  public void run() {
   while (true) {
    show();
   }
  }
 public synchronized void show() {
  if (sum > 0) {
   try {
    Thread.sleep(10);
   } catch (InterruptedException e) {
    e.printStackTrace();
   }
   System.out.println(sum);
   sum--;
  }
 }
}

Lock锁

锁定操作比synchronized代码块和synchronized方法更广泛, 同步代码块/同步方法具有的功能Lock都有,除此之外更强大,更体现面向对象。

public void lock() :加同步锁。
public void unlock() :释放同步锁。

使用如下：

public class Test {
 public static void main(String[] args) {
   MyRunnable r = new MyRunnable();
   Thread t1 = new Thread(r);
   Thread t2 = new Thread(r);
   Thread t3 = new Thread(r);
   t1.start();
   t2.start();
   t3.start();
 }
}
class MyRunnable implements Runnable {
  private int sum = 100;
  Lock l = new ReentrantLock();
  public void run() {
   while (true) {
    l.lock();
    if (sum > 0) {
     try {
      Thread.sleep(10);
      System.out.println(sum);
      sum--;
     } catch (InterruptedException e) {
      e.printStackTrace();
     } finally {
      l.unlock();
    }
   }
  }
 }
}

计时等待状态

为一个线程增加了限时等待的状态。在我们写1-100之间整数的案例中，为了增加线程安全问题出现的概率也为了减缓执行速度，我们在run方法中添加了sleep语句，这样就强制当前正在执行的线程休眠（暂停执行）。 其实当我们调用了sleep方法之后，当前执行的线程就进入到“休眠状态”，到时间自动苏醒，其实就是所谓的计时等待状态。

锁阻塞状态

一个线程正在等待一个监视器锁（锁对象）的线程处于的状态，也就是为获取锁对象的状态比如，线程A与线程B代码中使用同一锁，如果线程A获取到锁，那么线程B就进入到锁阻塞状态。

无限等待状态

一个线程处于正在无限期等待另一个线程执行一个特别的(唤醒)动作的这一状态，也就是调用wait()方法进入无限等待状态，直到调用notify方法，释放锁对象。
下面通过一段代码理解一下：

public class ThreadDemo {
 private static boolean isfinished;
 private static Object obj = new Object();
 public static void main(String[] args) {
  new Thread() {
   public void run() {
    System.out.println("开始下载图片");
    for (int i = 0; i <= 100; i++) {
     try {
      Thread.sleep(20);
     } catch (InterruptedException e) {
      e.printStackTrace();
     }
     System.out.println("down:图片已下载:" + i + "%");
    }
    System.out.println("图片下载完毕");
    isfinished = true;
    synchronized (obj) {
     obj.notify();
    }
    System.out.println("开始下载附件");
    for (int i = 0; i <= 100; i++) {
     try {
      Thread.sleep(20);
     } catch (InterruptedException e) {
      e.printStackTrace();
     }
     System.out.println("附件:图片已下载:" + i + "%");
    }
    System.out.println("附件下载完毕");
   }
  }.start();
  new Thread() {
   public void run() {
    if (!isfinished) {
     System.out.println("图片还没下载完成");
    }
    System.out.println("开始显示图片");
    try {
     synchronized (obj) {
      obj.wait();
     }
    } catch (InterruptedException e) {
     e.printStackTrace();
    }
    System.out.println("图片显示完毕");
   }
  }.start();
 }
}

通过上述案例我们会发现，一个调用了某个对象的wait 方法的线程会等待另一个线程调用此对象的 notify()方法。其实无限等待状态并不是一个线程的操作，它体现的是多个线程间的通信，可以理解为多个线程之间的协作关系，多个线程会争取锁，同时相互之间又存在协作关系。当多个线程协作时，比如A，B线程，如果A线程在可运行状态中调用了wait()方法那么A线程就进入了无限等待状态，同时失去了同步锁。假如这个时候B线程获取到了同步锁，在运行状态中调用了notify()方法，那么就会将无限等待的A线程唤醒。注意是唤醒，如果获取到锁对象，那么A线程唤醒后就进入可运行状态；如果没有获取锁对象，那么就进入到锁阻塞状态。

等待唤醒机制概述

这是多个线程间的一种协作机制。就是在一个线程进行了规定操作后，就进入等待状态（wait()），等待其他线程执行完他们的指定代码过后再将其唤醒（notify()）;在有多个线程进行等待时，如果需要，可以使用 notifyAll()来唤醒所有的等待线程。wait/notify 就是线程间的一种协作机制。

等待唤醒中的方法

  1. wait：线程不再活动，不再参与调度，因此不会浪费 CPU 资源，也不会去竞争锁了，这时的线程状态即是无限等待状态。它还要等着别的线程执行一个特别的动作，也即是通知（notify）在这个对象上等待的线程等待中释放出来，重新进入到调度队列中
  2. notify：把一个等待状态中的一个线程释放出来
  3. notifyAll：释放所有等待状态的线程。

调用wait和notify方法需要注意的细节

  1. wait方法与notify方法必须要由同一个锁对象调用。因为：对应的锁对象可以通过notify唤醒使用同一个锁对象调用的wait方法后的线程。
  2. wait方法与notify方法是属于Object类的方法的。因为：锁对象可以是任意对象，而任意对象的所属类都是继承了Object类的。
  3. wait方法与notify方法必须要在同步代码块或者是同步函数中使用。因为：必须要通过锁对象调用这2个方法。

线程池思想概述

我们使用线程的时候就去创建一个线程，这样实现起来非常简便，但是就会有一个问题： 如果并发的线程数量很多，并且每个线程都是执行一个时间很短的任务就结束了，这样频繁创建线程就会大大降低系统的效率，因为频繁创建线程和销毁线程需要时间。 那么有没有一种办法使得线程可以复用，就是执行完一个任务，并不被销毁而是可以继续执行其他的任务？ 在Java中可以通过线程池来达到这样的效果。

线程池概念

其实就是一个容纳多个线程的容器，其中的线程可以反复使用，省去了频繁创建线程对象的操作，无需反复创建线程而消耗过多资源。利用线程池能够带来的好处：

  1. 降低资源消耗。减少了创建和销毁线程的次数，每个工作线程都可以被重复利用，可执行多个任务。
  2. 提高响应速度。当任务到达时，任务可以不需要的等到线程创建就能立即执行。

线程池的使用

线程池接口是 ExecutorService 。Executors类中有个创建线程池的方法如下：public static ExecutorService newFixedThreadPool(int nThreads) ：返回线程池对象。获取到了一个线程池ExecutorService 对象，然后定义一个使用线程池对象的方法如下：public Future<?> submit(Runnable task) :获取线程池中的某一个线程对象

使用线程池中线程对象的步骤：

  1. 创建线程池对象。
  2. 创建Runnable接口子类对象。(task)
  3. 提交Runnable接口子类对象。(take task)
  4. 关闭线程池(一般不做)。

实现代码：

public class Test {
 public static void main(String[] args) {
  // 1、生产一个指定线程数量的线程池
  ExecutorService es = Executors.newFixedThreadPool(2);
  // 2、调用submit方法，传递线程任务（实现类），开启线程执行run方法
  es.submit(new RunnableImpl());// Thread[pool-1-thread-2,5,main]执行
  // 线程池会一直开启， 使用完了线程，会自动把线程会还给线程池，线程可以继续使用
  es.submit(new RunnableImpl());// Thread[pool-1-thread-1,5,main]执行
  es.submit(new RunnableImpl());// Thread[pool-1-thread-2,5,main]执行
  // 调用ExecutorService中的方法shutdown销毁线程池(不建议执行)
  es.shutdown();
//es.submit(new RunnableImpl());// 抛异常，线程池都没有了，就不能获取线程了
 }
}
// 创建一个类，实现Runnable接口，重写run方法，设置线程任务
class RunnableImpl implements Runnable {
 @Override
 public void run() {
  System.out.println(Thread.currentThread()+ "执行");
 }
}
wudongjian
关注
专栏目录
线程知识点
superromantic的博客
05-04 180
线程 线程共有5中状态：新建、可运行(runnable)、运行(running)，阻塞和死亡。 当使用new操作符创建新线程时，线程处于“新建”状态。 当调用start（）方法时，线程处于可运行状态。 阻塞状态是指线程因为某种原因放弃了cpu 使用权，即让出了cpu分片时间，暂时停止运行。直到线程进入可运行状态，才有机会再次获得cpu时间 转到运行状态。 阻塞的情况分三种： (一). 等待阻塞：运...
线程(Thread)知识点总结
weixin_44536951的博客
12-10 967
多线程 并行与并发 并发:指的是两个或者多个事件(任务)在同一时间段内发生的 并行:指的是两个或者多个事件(任务)在同一时时刻发生(同时发生)的 线程与进程 进程:是指内存中运行的应用程序,每个进程都有一个独立的内存空间,一个应用程序可以同时运行多个线程;进程也是程序的一次执行过程,是系统运行程序的基本单位;系统运行一个程序就是一个进程从创建,运行到消亡的过程 线程:线程是进程中的一个执行单元,负责当前进程中程序的运行,一个程序中至少有一个线程,一个进程可以有多个线程,这个应用程序也可以称之为多线程
线程基础知识点
06-20 721
一、概念 进程并不执行任务，只是为线程提供空间和资源，线程才是执行任务的实体。
Java多线程知识点总结
08-19
Java多线程是Java编程语言中一个非常重要的概念...理解这些知识点对于解决并发编程中的问题，比如资源竞争、死锁、线程安全性等问题，至关重要。在实际开发中，正确地应用多线程机制可以显著提升程序的性能和用户体验。
linux线程间的同步与互斥知识点总结
09-14
在Linux系统中，线程间的同步与互斥是多线程编程中至关重要的概念，它们确保了多个线程在并发执行时对共享资源的有效管理和安全访问。本文将深入探讨这两个主题。 首先，线程同步是指通过特定机制协调线程的执行...
多线程知识总结
08-10
### 多线程知识总结 #### 一、线程基础概念 **线程状态：** 在探讨多线程之前，我们需要了解线程的基本状态转换。一个典型的线程生命周期包括以下几个阶段： 1. **Start（启动）：** 当线程被创建后调用`start()`...
Linux多线程编程知识点总结（C语言）（csdn）————程序.pdf
12-01
本文主要围绕Linux下C语言实现的多线程编程进行知识点总结，涉及线程与进程的区别、多线程的优势、Pthreads API以及线程安全和死锁预防。 首先，线程和进程是操作系统中两种基本的执行单元。线程是进程内部的执行流...
线程的知识点
yz1534194168的博客
10-08 163
线程 一、进程与线程 进程就是正在运行的程序。线程是程序执行单元，执行路径，是程序使用cpu的最基本单位。其关系为 进程包含线程，进程是有若干线程组成。 1.多进程与多线程 多进程：就是可以在同一时间断内执行多个任务，也就是计算机即可以运行qq的同时，运行酷狗。 多线程：程序有多条执行路径，即执行qq聊天窗口，也可以打开新的窗口。 （1）多线程的意义 多线程是为了提高程序的使用效率，程序的执行就是...
线程相关的知识点
最新发布
weixin_57219176的博客
04-02 713
线程相关的知识点
线程知识点（笔记）
qq_40796888的博客
10-19 3308
线程知识点（笔记） 线程 synchronized和Lock锁的区别？ 1.存在层次上，synchronized是Java的关键字，在jvm层面上；而Lock是一个类 2.锁的释放上，synchronized是 1、以获取锁的线程执行完同步代码，释放锁 2、线程执行发生异常，jvm会让线程释放锁； 而Lock是在finally中必须释放锁(lock.unlock())，不然容易造成线程死锁 3.锁的获取上，synchronized是假设A线程获得锁，B线程等待。如果A线程阻塞，B线程会一直等待； 而Lock
线程相关知识点
qq_45792764的博客
08-09 499
线程相关知识点
线程基本知识点
m0_50959444的博客
02-12 297
1、线程、进程概念理解 线程 线程是cpu独立运行和独立调度的基本单位 线程可以理解为是操作系统中的应用程序（一段代码） 线程是进程中一段可以单独执行的代码，线程可共享进程的内存空间 进程 进程是资源分配的基本单位 进程可以理解为操作系统 当一个程序被加载到内存并且被执行的时候这个程序就成为一个进程（运行中的程序） 线程调度 线程获得cpu时间片，线程才能够执行 线程优先级不同，采用抢占式调度机制，优先级相同时，采用分时调度机制。 java线程与原生操作系统线程有直接的映射关系
线程的基本知识点
吹 梦到西州的博客
12-20 122
多线程和单线程
线程知识点整理
吃肉会瘦
06-02 336
线程的概念 线程和进程的区别 进程：系统分配资源的最小单位，一个进程里最少有个一个线程 线程：CPU调度的最小单位 并发和并行： 线程的启动方式 new Thread Runnable接口 Callable接口 线程的方法 线程的状态 线程安全问题 锁的种类 synchronized synchronized(内置锁)属于可重入锁，默认是非公平锁。 synchronized的缺点 1：获取锁后,无法中断。 2：无法尝试获取锁，取不到时只会一直等待锁。 对象锁与类锁 1：锁某个对象或者当前当前类的实例 2：类
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值