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 代码稍微复杂一些
目录
相关文章
|
6天前
|
安全 Java 开发者
深入解读JAVA多线程:wait()、notify()、notifyAll()的奥秘
在Java多线程编程中,`wait()`、`notify()`和`notifyAll()`方法是实现线程间通信和同步的关键机制。这些方法定义在`java.lang.Object`类中,每个Java对象都可以作为线程间通信的媒介。本文将详细解析这三个方法的使用方法和最佳实践,帮助开发者更高效地进行多线程编程。 示例代码展示了如何在同步方法中使用这些方法,确保线程安全和高效的通信。
25 9
|
9天前
|
存储 安全 Java
Java多线程编程的艺术:从基础到实践####
本文深入探讨了Java多线程编程的核心概念、应用场景及其实现方式,旨在帮助开发者理解并掌握多线程编程的基本技能。文章首先概述了多线程的重要性和常见挑战,随后详细介绍了Java中创建和管理线程的两种主要方式:继承Thread类与实现Runnable接口。通过实例代码,本文展示了如何正确启动、运行及同步线程,以及如何处理线程间的通信与协作问题。最后,文章总结了多线程编程的最佳实践,为读者在实际项目中应用多线程技术提供了宝贵的参考。 ####
|
6天前
|
监控 安全 Java
Java中的多线程编程:从入门到实践####
本文将深入浅出地探讨Java多线程编程的核心概念、应用场景及实践技巧。不同于传统的摘要形式,本文将以一个简短的代码示例作为开篇,直接展示多线程的魅力,随后再详细解析其背后的原理与实现方式,旨在帮助读者快速理解并掌握Java多线程编程的基本技能。 ```java // 简单的多线程示例:创建两个线程,分别打印不同的消息 public class SimpleMultithreading { public static void main(String[] args) { Thread thread1 = new Thread(() -> System.out.prin
|
9天前
|
Java
JAVA多线程通信:为何wait()与notify()如此重要?
在Java多线程编程中,`wait()` 和 `notify()/notifyAll()` 方法是实现线程间通信的核心机制。它们通过基于锁的方式,使线程在条件不满足时进入休眠状态,并在条件满足时被唤醒,从而确保数据一致性和同步。相比其他通信方式,如忙等待,这些方法更高效灵活。 示例代码展示了如何在生产者-消费者模型中使用这些方法实现线程间的协调和同步。
24 3
|
8天前
|
安全 Java
Java多线程集合类
本文介绍了Java中线程安全的问题及解决方案。通过示例代码展示了使用`CopyOnWriteArrayList`、`CopyOnWriteArraySet`和`ConcurrentHashMap`来解决多线程环境下集合操作的线程安全问题。这些类通过不同的机制确保了线程安全,提高了并发性能。
|
9天前
|
Java
java小知识—进程和线程
进程 进程是程序的一次执行过程,是系统运行的基本单位,因此进程是动态的。系统运行一个程序即是一个进程从创建,运行到消亡的过程。简单来说,一个进程就是一个执行中的程序,它在计算机中一个指令接着一个指令地执行着,同时,每个进程还占有某些系统资源如CPU时间,内存空间,文件,文件,输入输出设备的使用权等等。换句话说,当程序在执行时,将会被操作系统载入内存中。 线程 线程,与进程相似,但线程是一个比进程更小的执行单位。一个进程在其执行的过程中产生多个线程。与进程不同的是同类的多个线程共享同一块内存空间和一组系统资源,所以系统在产生一个线程,或是在各个线程之间做切换工作时,负担要比
20 1
|
9天前
|
Java UED
Java中的多线程编程基础与实践
【10月更文挑战第35天】在Java的世界中,多线程是提升应用性能和响应性的利器。本文将深入浅出地介绍如何在Java中创建和管理线程,以及如何利用同步机制确保数据一致性。我们将从简单的“Hello, World!”线程示例出发,逐步探索线程池的高效使用,并讨论常见的多线程问题。无论你是Java新手还是希望深化理解,这篇文章都将为你打开多线程的大门。
|
1月前
|
存储 消息中间件 资源调度
C++ 多线程之初识多线程
这篇文章介绍了C++多线程的基本概念,包括进程和线程的定义、并发的实现方式,以及如何在C++中创建和管理线程,包括使用`std::thread`库、线程的join和detach方法,并通过示例代码展示了如何创建和使用多线程。
43 1
C++ 多线程之初识多线程
|
24天前
|
Java 开发者
在Java多线程编程中,创建线程的方法有两种:继承Thread类和实现Runnable接口
【10月更文挑战第20天】在Java多线程编程中,创建线程的方法有两种:继承Thread类和实现Runnable接口。本文揭示了这两种方式的微妙差异和潜在陷阱,帮助你更好地理解和选择适合项目需求的线程创建方式。
19 3
|
24天前
|
Java 开发者
在Java多线程编程中,选择合适的线程创建方法至关重要
【10月更文挑战第20天】在Java多线程编程中,选择合适的线程创建方法至关重要。本文通过案例分析,探讨了继承Thread类和实现Runnable接口两种方法的优缺点及适用场景,帮助开发者做出明智的选择。
16 2