Java多线程简介

简介: Java多线程

Java.Thread(线)


image.png


image.png


image.png

1 进程和线程的概念以及他们直接的关系

前言:说起进程,就不得不说下程序,程序是指令和数据的有序集合,其本身没有任何允许的含义,是一个静态的概念

进程(process)

进程是执行程序的一个执行过程,它是一个动态的概念,是系统资源分配的单位

一个进程可以有多个线程,比如视频中看视频听声音看弹幕

通常在一个进程中包含若干个线程,当然一个进程中至少包含一个线程,不然没有存在的意义,线程是CPU调度和执行的单位

进程是资源(CPU、内存等)分配的基本单位,它是程序执行时的一个实例。程序运行时系统就会创建一个进程,并为它分配资源,然后把该进程放入进程就绪队列,进程调度器选中它的时候就会为它分配CPU时间,程序开始真正运行。

线程(thread)

Java中默认的线程有main(自己写的用户线程),gc(垃圾回收,是JVM给我们写的叫守护线程)

线程是一条执行路径,是程序执行时的最小单位,它是进程的一个执行流,是CPU调度和分派的基本单位,一个进程可以由很多个线程组成,线程间共享进程的所有资源,每个线程有自己的堆栈和局部变量。线程由CPU独立调度执行,在多CPU环境下就允许多个线程同时运行。同样多线程也可以实现并发操作,每个请求分配一个线程来处理。

一个正在运行的软件(如迅雷)就是一个进程,一个进程可以同时运行多个任务( 迅雷软件可以同时下载多个文件,每个下载任务就是一个线程), 可以简单的认为进程是线程的集合。

进程与线程的关系

一个程序就是一个进程,而一个程序中的多个任务则被称为线程。进程是表示资源分配的基本单位,又是调度运行的基本单位。,亦即执行处理机调度的基本单位。 进程和线程的关系:

一个线程只能属于一个进程,而一个进程可以有多个线程,但至少有一个线程。线程是操作系统可识别的最小执行和调度单位。

资源分配给进程,同一进程的所有线程共享该进程的所有资源。同一进程中的多个线程共享代码段(代码和常量),数据段(全局变量和静态变量),扩展段(堆存储)。但是每个线程拥有自己的栈段,栈段又叫运行时段,用来存放所有局部变量和临时变量,即每个线程都有自己的堆栈和局部变量。

处理机分给线程,即真正在处理机上运行的是线程。

线程在执行过程中,需要协作同步。不同进程的线程间要利用消息通信的办法实现同步。

注意

很多多线程是模拟出来的,真正的多线程指的是有多个CPU,即多核,如服务器,如果是模拟出来的多线程,即在一个CPU的情况下,在同一个时间点,cpu只能执行一个代码,因为切换的速度很快,所以就有同时执行的错局

2 start()方法和run()方法的区别

   start方法是启动线程,run方法只是去执行线程的代码

3 线程创建的3种方式

因为Java是单继承,所以推荐使用实现runnable接口,runnable可以避免单继承局限性,使用灵活方便,方便同一个对象被多个线程调用

1 继承Thread类(重点)

Thread源码也是实现Runable接口

1 继承Thread类

2 重写run方法,在run方法中编写线程执行代码

3 创建线程对象,调用它的start方法去启动线程

       4 总结: 线程开启不一定立刻执行,是由CPU调度安排,每次执行结果都不一样.他们是交替同时执行的


package com.wyh.thread;
/**
 * @program: Thread
 * @description: 多线程测试
 * @author: 魏一鹤
 * @createDate: 2021-12-23 23:37
 **/
//创建线程的方式1:继承Thread类 重写它的Run方法,调用start调用线程
public class TestThread1 extends Thread {
    @Override
public void run() {
//run方法线程体
        for (int i = 0; i < 10; i++) {
            System.out.println("我是run方法 = " + i);
        }
    }
public static void main(String[] args){
//创建一个线程对象
        TestThread1 testThread1 = new TestThread1();
//调用它的start方法去开启线程
        //start方法才是开启线程  run方法知识去执行线程中的代码
        testThread1.start();
//testThread1.run();
        //main方法 主线程
        for (int i = 0; i < 2000; i++) {
            System.out.println("我是main方法 = " + i);
        }
    }
}


2 实现Runnable接口(重点)

1 实现runnable接口

2 实现run方法,编写线程代码

3 新创建线程对象,调用start方法去启动线程


package com.wyh.thread;
/**
 * @program: Thread
 * @description: 实现runnable接口
 * @author: 魏一鹤
 * @createDate: 2021-12-24 23:59
 **/
//创建线程方式2 实现runnable接口,重写run方法 ,执行线程需要丢入runnable接口实现类,调用start方法
public class TestThread2  implements  Runnable{
    @Override
public void run() {
//run方法线程体
        for (int i = 0; i < 100; i++) {
            System.out.println("我是run方法 = " + i);
        }
    }
public static void main(String[] args){
//创建runnable接口的实现类对象
        TestThread2 testThread2 = new TestThread2();
//创建线程,通过线程对象开启线程 代理
        Thread thread=new Thread(testThread2);
//调用start方法
        thread.start();
//也可以简写为以下格式
       // new Thread(testThread2).start();
        //main方法 主线程
        for (int i = 0; i < 2000; i++) {
            System.out.println("我是main方法 = " + i);
        }
    }
}


3 实现Callable接口(了解)

1 实现callable接口,需要返回值类型
2 重写call方法,需要抛出异常
3 创建目标对象
4 开启服务(创建执行服务)
5 提交执行
6 获取结果
7 关闭服务


///////////////////////////单个线程
package com.wyh.thread;
import java.util.concurrent.*;
/**
 * @program: Thread
 * @description: 实现callable接口
 * @author: 魏一鹤
 * @createDate: 2021-12-26 23:40
 **/
public class TestThread5 implements Callable<Object> {
//实现callable需要重写它的call方法
    @Override
public Object call() throws Exception {
for (int i = 0; i < 100; i++) {
            System.out.println("我在学习"+i);
        }
return null;
    }
public static void main(String[] args) throws Exception {
//线程体 实现类对象
        TestThread5 testThread5 = new TestThread5();
//创建执行服务                              创建线程池    需要几个线程就写几个
        ExecutorService executorService = Executors.newFixedThreadPool(1);
//提交执行
        Future<Object> submit = executorService.submit(testThread5);
//获取结果
        Object o = submit.get();
//打印返回结果
        System.out.println(o);
//关闭服务
        executorService.shutdown();
//主线程
        for (int i = 0; i < 1000; i++) {
            System.out.println("我在划水"+i);
        }
    }
}
///////////////////////////多个线程
package com.wyh.thread;
import java.util.concurrent.*;
/**
 * @program: Thread
 * @description: 实现callable接口
 * @author: 魏一鹤
 * @createDate: 2021-12-26 23:40
 **/
public class TestThread5 implements Callable<Object> {
//实现callable需要重写它的call方法
    @Override
public Object call() throws Exception {
for (int i = 0; i < 100; i++) {
            System.out.println("我在学习"+i);
        }
return null;
    }
public static void main(String[] args) throws Exception {
//线程体 实现类对象
        TestThread5 testThread1 = new TestThread5();
        TestThread5 testThread2 = new TestThread5();
        TestThread5 testThread3 = new TestThread5();
//创建执行服务                              创建线程池    需要几个线程就写几个
        ExecutorService executorService = Executors.newFixedThreadPool(3);
//提交执行
        Future<Object> submit1 = executorService.submit(testThread1);
        Future<Object> submit2 = executorService.submit(testThread2);
        Future<Object> submit3 = executorService.submit(testThread3);
//获取结果
        Object o1 = submit1.get();
        Object o2 = submit2.get();
        Object o3 = submit2.get();
//打印返回结果
        System.out.println(o1);
        System.out.println(o2);
        System.out.println(o3);
//关闭服务
        executorService.shutdown();
//主线程
        for (int i = 0; i < 1000; i++) {
            System.out.println("我在划水"+i);
        }
    }
}

实现callable接口的特点

优点
1 可以自定义返回值
2 可以抛出异常
缺点
1 代码稍微复杂一些
目录
相关文章
|
5天前
|
Java 开发者
Java多线程编程中的常见误区与最佳实践####
本文深入剖析了Java多线程编程中开发者常遇到的几个典型误区,如对`start()`与`run()`方法的混淆使用、忽视线程安全问题、错误处理未同步的共享变量等,并针对这些问题提出了具体的解决方案和最佳实践。通过实例代码对比,直观展示了正确与错误的实现方式,旨在帮助读者构建更加健壮、高效的多线程应用程序。 ####
|
4天前
|
安全 Java 开发者
Java 多线程并发控制:深入理解与实战应用
《Java多线程并发控制:深入理解与实战应用》一书详细解析了Java多线程编程的核心概念、并发控制技术及其实战技巧,适合Java开发者深入学习和实践参考。
|
4天前
|
Java 开发者
Java多线程编程的艺术与实践####
本文深入探讨了Java多线程编程的核心概念、应用场景及实践技巧。不同于传统的技术文档,本文以实战为导向,通过生动的实例和详尽的代码解析,引领读者领略多线程编程的魅力,掌握其在提升应用性能、优化资源利用方面的关键作用。无论你是Java初学者还是有一定经验的开发者,本文都将为你打开多线程编程的新视角。 ####
|
3天前
|
存储 安全 Java
Java多线程编程中的并发容器:深入解析与实战应用####
在本文中,我们将探讨Java多线程编程中的一个核心话题——并发容器。不同于传统单一线程环境下的数据结构,并发容器专为多线程场景设计,确保数据访问的线程安全性和高效性。我们将从基础概念出发,逐步深入到`java.util.concurrent`包下的核心并发容器实现,如`ConcurrentHashMap`、`CopyOnWriteArrayList`以及`BlockingQueue`等,通过实例代码演示其使用方法,并分析它们背后的设计原理与适用场景。无论你是Java并发编程的初学者还是希望深化理解的开发者,本文都将为你提供有价值的见解与实践指导。 --- ####
|
9天前
|
安全 Java 开发者
深入解读JAVA多线程:wait()、notify()、notifyAll()的奥秘
在Java多线程编程中,`wait()`、`notify()`和`notifyAll()`方法是实现线程间通信和同步的关键机制。这些方法定义在`java.lang.Object`类中,每个Java对象都可以作为线程间通信的媒介。本文将详细解析这三个方法的使用方法和最佳实践,帮助开发者更高效地进行多线程编程。 示例代码展示了如何在同步方法中使用这些方法,确保线程安全和高效的通信。
32 9
|
6天前
|
安全 Java 开发者
Java多线程编程中的常见问题与解决方案
本文深入探讨了Java多线程编程中常见的问题,包括线程安全问题、死锁、竞态条件等,并提供了相应的解决策略。文章首先介绍了多线程的基础知识,随后详细分析了每个问题的产生原因和典型场景,最后提出了实用的解决方案,旨在帮助开发者提高多线程程序的稳定性和性能。
|
9天前
|
监控 安全 Java
Java中的多线程编程:从入门到实践####
本文将深入浅出地探讨Java多线程编程的核心概念、应用场景及实践技巧。不同于传统的摘要形式,本文将以一个简短的代码示例作为开篇,直接展示多线程的魅力,随后再详细解析其背后的原理与实现方式,旨在帮助读者快速理解并掌握Java多线程编程的基本技能。 ```java // 简单的多线程示例:创建两个线程,分别打印不同的消息 public class SimpleMultithreading { public static void main(String[] args) { Thread thread1 = new Thread(() -> System.out.prin
|
10天前
|
安全 Java
Java多线程集合类
本文介绍了Java中线程安全的问题及解决方案。通过示例代码展示了使用`CopyOnWriteArrayList`、`CopyOnWriteArraySet`和`ConcurrentHashMap`来解决多线程环境下集合操作的线程安全问题。这些类通过不同的机制确保了线程安全,提高了并发性能。
|
6月前
|
存储 安全 Java
深入理解Java并发编程:线程安全与锁机制
【5月更文挑战第31天】在Java并发编程中,线程安全和锁机制是两个核心概念。本文将深入探讨这两个概念,包括它们的定义、实现方式以及在实际开发中的应用。通过对线程安全和锁机制的深入理解,可以帮助我们更好地解决并发编程中的问题,提高程序的性能和稳定性。
|
3月前
|
存储 安全 Java
解锁Java并发编程奥秘:深入剖析Synchronized关键字的同步机制与实现原理,让多线程安全如磐石般稳固!
【8月更文挑战第4天】Java并发编程中,Synchronized关键字是确保多线程环境下数据一致性与线程安全的基础机制。它可通过修饰实例方法、静态方法或代码块来控制对共享资源的独占访问。Synchronized基于Java对象头中的监视器锁实现,通过MonitorEnter/MonitorExit指令管理锁的获取与释放。示例展示了如何使用Synchronized修饰方法以实现线程间的同步,避免数据竞争。掌握其原理对编写高效安全的多线程程序极为关键。
64 1
下一篇
无影云桌面