Java多线程-实例解析

本文涉及的产品
公共DNS(含HTTPDNS解析),每月1000万次HTTP解析
全局流量管理 GTM,标准版 1个月
云解析 DNS,旗舰版 1个月
简介: Java多线程-实例解析 Java多线程实例 3种实现方法Java中的多线程有三种实现方式:1.继承Thread类,重写run方法。Thread本质上也是一个实现了Runnable的实例,他代表一个线程的实例,并且启动线程的唯一方法就是通过Thread类的start方法。

Java多线程-实例解析

Java多线程实例 3种实现方法
Java中的多线程有三种实现方式:
1.继承Thread类,重写run方法。Thread本质上也是一个实现了Runnable的实例,他代表一个线程的实例,并且启动线程的唯一方法就是通过Thread类的start方法。
2.实现Runnable接口,并实现该接口的run()方法.创建一个Thread对象,用实现的Runnable接口的对象作为参数实例化Thread对象,调用此对象的start方法。
3.实现Callable接口,重写call方法。Callable接口与Runnable接口的功能类似,但提供了比Runnable更强大的功能。有以下三点
1).Callable可以在人物结束后提供一个返回值,Runnable没有提供这个功能。
2).Callable中的call方法可以抛出异常,而Runnable的run方法不能抛出异常。

3).运行Callable可以拿到一个Future对象,表示异步计算的结果,提供了检查计算是否完成的方法。

需要注意的是,无论用那种方式实现了多线程,调用start方法并不意味着立即执行多线程代码,而是使得线程变为可运行状态。

run start的区别
start方法是启动一个线程,而线程中的run方法来完成实际的操作。

如果开发人员直接调用run方法,那么就会将这个方法当作一个普通函数来调用,并没有多开辟线程,开发人员如果希望多线程异步执行,则需要调用start方法。

sleep wait的区别
1.两者处理的机制不同,sleep方法主要是,让线程暂停执行一段时间,时间一到自动恢复,并不会释放所占用的锁,当调用wait方法以后,他会释放所占用的对象锁,等待其他线程调用notify方法才会再次醒来。
2.sleep是Threa的静态方法,是用来控制线程自身流程的,而wait是object的方法,用于进行线程通信。
3.两者使用的区域不同。sleep可以在任何地方使用,wait必须放在同步控制方法,或者语句块中执行。




synchronized notify wait的运用
synchronized关键字有两种用法,synchronized方法和synchronized语句块。
public synchronized void function(){}
synchronized(object){}
当某个资源被synchronized所修饰,线程1线程2等多个线程在共同请求这个资源,线程1先请求到,调用了对象的wait方法释放了对象的锁,此时线程2可以对这个对象进行访问,在工作结束时可以调用对象的notify方法,唤醒等待队列中正在等待的线程,此时被唤醒的线程将会再一次拿到对象锁,对对象进行操作。可以调用notifyAll方法,唤醒等待队列中的所有线程。


需要注意的是一个线程被唤醒不代表立即获取对象锁,必须等调用的线程对象的方法推出synchronized块释放对象锁后,被唤醒的进程才会获得对象锁。




以下为大家提供一个简单的代码实例:


分别用Runnable和Thread方法实现,展示各个方法的


实现Runnable实现多线程的方法



   
   
  1. public class TestRunnable implements Runnable {
  2. private int time=1;
  3. private SourceA s;
  4. private String id = "001";
  5. public TestRunnable(SourceA s){
  6. this.s = s;
  7. }
  8. public void setTime(int time) {
  9. this.time = time;
  10. }
  11. @Override
  12. public void run() {
  13. try {
  14. System.out.println("i will sleep"+ time);
  15. Thread.sleep(time);
  16. } catch (InterruptedException e) {
  17. // TODO Auto-generated catch block
  18. e.printStackTrace();
  19. }
  20. synchronized(s){
  21. s.notify();
  22. System.out.println("我唤醒了002!");
  23. System.out.println("我存入了id"+id);
  24. s.setSource(id);
  25. }
  26. }
  27. }

继承Thread实现多线程的方法



   
   
  1. public class TestThread extends Thread {
  2. private int time = 1;
  3. private SourceA s = null;
  4. String id = "002";
  5. public void setTime(int time) {
  6. this.time = time;
  7. }
  8. public TestThread(SourceA s){
  9. this.s = s ;
  10. }
  11. @Override
  12. public void run() {
  13. try {
  14. System.out.println("i will sleep"+ time);
  15. sleep(time);
  16. } catch (InterruptedException e) {
  17. // TODO Auto-generated catch block
  18. e.printStackTrace();
  19. }
  20. synchronized(s){
  21. try {
  22. System.out.println("我"+ id +"要进行等待了");
  23. s.wait();
  24. } catch (InterruptedException e) {
  25. // TODO Auto-generated catch block
  26. e.printStackTrace();
  27. }
  28. System.out.println("我被唤醒了");
  29. System.out.println("我存入了id"+id);
  30. s.setSource(id);
  31. }
  32. }
  33. }

SourceA类代码



   
   
  1. public class SourceA {
  2. private List <String> list = new ArrayList <String>();
  3. public synchronized void getSource(){
  4. for(int i=0;i <list.size();i++){
  5. System.out.println(list.get(i));
  6. }
  7. }
  8. public synchronized void setSource(String id){
  9. list.add(id);
  10. }
  11. }
Test测试类代码:


   
   
  1. public void test(){
  2. SourceA s = new SourceA();
  3. TestThread tt = new TestThread(s);
  4. TestRunnable tr = new TestRunnable(s);
  5. Thread t = new Thread(tr);
  6. System.out.println("调用线程1");
  7. tt.start();
  8. System.out.println("调用线程2");
  9. t.start();
  10. }

原文地址https://blog.csdn.net/wfa270/article/details/80858837
相关文章
|
7天前
|
存储 缓存 Java
Java 并发编程——volatile 关键字解析
本文介绍了Java线程中的`volatile`关键字及其与`synchronized`锁的区别。`volatile`保证了变量的可见性和一定的有序性,但不能保证原子性。它通过内存屏障实现,避免指令重排序,确保线程间数据一致。相比`synchronized`,`volatile`性能更优,适用于简单状态标记和某些特定场景,如单例模式中的双重检查锁定。文中还解释了Java内存模型的基本概念,包括主内存、工作内存及并发编程中的原子性、可见性和有序性。
Java 并发编程——volatile 关键字解析
|
5天前
|
Java 数据库连接 Spring
反射-----浅解析(Java)
在java中,我们可以通过反射机制,知道任何一个类的成员变量(成员属性)和成员方法,也可以堆任何一个对象,调用这个对象的任何属性和方法,更进一步我们还可以修改部分信息和。
|
28天前
|
缓存 Java 调度
多线程编程核心:上下文切换深度解析
在现代计算机系统中,多线程编程已成为提高程序性能和响应速度的关键技术。然而,多线程编程中一个不可避免的概念就是上下文切换(Context Switching)。本文将深入探讨上下文切换的概念、原因、影响以及优化策略,帮助你在工作和学习中深入理解这一技术干货。
43 10
|
28天前
|
调度 开发者
核心概念解析:进程与线程的对比分析
在操作系统和计算机编程领域,进程和线程是两个基本而核心的概念。它们是程序执行和资源管理的基础,但它们之间存在显著的差异。本文将深入探讨进程与线程的区别,并分析它们在现代软件开发中的应用和重要性。
53 4
|
28天前
|
算法 调度 开发者
多线程编程核心:上下文切换深度解析
在多线程编程中,上下文切换是一个至关重要的概念,它直接影响到程序的性能和响应速度。本文将深入探讨上下文切换的含义、原因、影响以及如何优化,帮助你在工作和学习中更好地理解和应用多线程技术。
36 4
|
27天前
|
存储 算法 Java
Java内存管理深度解析####
本文深入探讨了Java虚拟机(JVM)中的内存分配与垃圾回收机制,揭示了其高效管理内存的奥秘。文章首先概述了JVM内存模型,随后详细阐述了堆、栈、方法区等关键区域的作用及管理策略。在垃圾回收部分,重点介绍了标记-清除、复制算法、标记-整理等多种回收算法的工作原理及其适用场景,并通过实际案例分析了不同GC策略对应用性能的影响。对于开发者而言,理解这些原理有助于编写出更加高效、稳定的Java应用程序。 ####
|
27天前
|
存储 监控 算法
Java虚拟机(JVM)垃圾回收机制深度解析与优化策略####
本文旨在深入探讨Java虚拟机(JVM)的垃圾回收机制,揭示其工作原理、常见算法及参数调优方法。通过剖析垃圾回收的生命周期、内存区域划分以及GC日志分析,为开发者提供一套实用的JVM垃圾回收优化指南,助力提升Java应用的性能与稳定性。 ####
|
7月前
|
存储 安全 Java
深入理解Java并发编程:线程安全与锁机制
【5月更文挑战第31天】在Java并发编程中,线程安全和锁机制是两个核心概念。本文将深入探讨这两个概念,包括它们的定义、实现方式以及在实际开发中的应用。通过对线程安全和锁机制的深入理解,可以帮助我们更好地解决并发编程中的问题,提高程序的性能和稳定性。
|
4月前
|
存储 安全 Java
解锁Java并发编程奥秘:深入剖析Synchronized关键字的同步机制与实现原理,让多线程安全如磐石般稳固!
【8月更文挑战第4天】Java并发编程中,Synchronized关键字是确保多线程环境下数据一致性与线程安全的基础机制。它可通过修饰实例方法、静态方法或代码块来控制对共享资源的独占访问。Synchronized基于Java对象头中的监视器锁实现,通过MonitorEnter/MonitorExit指令管理锁的获取与释放。示例展示了如何使用Synchronized修饰方法以实现线程间的同步,避免数据竞争。掌握其原理对编写高效安全的多线程程序极为关键。
71 1
|
5月前
|
安全 Java 开发者
Java并发编程中的线程安全问题及解决方案探讨
在Java编程中,特别是在并发编程领域,线程安全问题是开发过程中常见且关键的挑战。本文将深入探讨Java中的线程安全性,分析常见的线程安全问题,并介绍相应的解决方案,帮助开发者更好地理解和应对并发环境下的挑战。【7月更文挑战第3天】
109 0

推荐镜像

更多