Java基础之多线程

最新推荐文章于 2024-10-16 10:13:45 发布
最新推荐文章于 2024-10-16 10:13:45 发布
阅读量137 收藏
点赞数
分类专栏： Java基础 文章标签： 多线程 java 并发编程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_33034955/article/details/107037239
版权

Java基础之多线程

前言

本文是对java基础复习时候的文章，拿来做总结。

一、概述

1、进程和线程

大家都是自诩为程序猿，那什么是程序呢？程序就是指为了完成特定任务，用某种语言编写的一组指令的集合。即指一段静态的代码，静态对象。了解了程序，接下来就是进程和线程。

进程：是程序的一次执行过程，或者是正在运行的一个程序，是一个动态的过程，。

线程：进程进一步的细分就是线程，是程序内的一条执行路径。

2、并行和并发

并行：多个CPU同时执行多个任务，比如：多个人同时做不同的事

并发：一个CPU同时执行多个任务。比如：多个人同时做一件事

二、线程的创建和使用

1、线程的创建

线程的创建有多种方式，本文主要介绍两种方式：继承Thread类和实现Runnable接口。

  • 继承Thread类

    • 实现方法：

    1、创建一个类继承Thread类

    2、实现Thread类的run()方法

    3、创建子类的对象

    4、通过子类对象调用start()方法启动线程

    • 代码：
    public class ImplThread extends Thread {
    @Override
    public void run() {
        for (int i = 0; i < 200; i++) {
            System.out.println("子线程开始发车，准备上车。。。。"+i);
        }
    }

    public static void main(String[] args) {
        ImplThread implThread = new ImplThread();
        implThread.start();
        for (int i = 0; i < 200; i++) {
            System.out.println("主线程开始上车，准备发车。。。。"+i);
        }
    }
}

  • 实现Runnable接口

    • 实现方法：

    1、创建一个类实现Runnable接口

    2、实现run()方法

    3、创建实现类对象

    4、将此对象传入到Thread类的构造方法中，创建线程对象

    5、通过此对象调用start()方法启动线程

    • 代码：
    public class ImplRunnable implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 200; i++) {
            System.out.println(Thread.currentThread().getName()+"线程正在执行。。。"+i);
        }
    }

    public static void main(String[] args) {
        ImplRunnable im = new ImplRunnable();
        new Thread(im).start();
        new Thread(im).start();
        new Thread(im).start();
    }
}

2、线程的使用

  • 常用方法：
●void start():启动线程，并执行对象的run()方法
●run():线程在被调度时执行的操作
●String getName():返回线程的名称
●void setName(String name):设置该线程名称
●static Thread currentThread():返回当前线程。在Thread 子类中就是this,通常用于主线程和Runnable实现类
●yield():释放当前CPU的执行权
●join():在线程a中调用线程b的join方法，此时线程a进入阻塞状态，直到线程b完全执行完之后，线程a才结束阻塞状态。
●stop():强制结束线程（已经过时）
●sleep(long milltime):让当前线程睡眠指定的milltime毫秒时间内，当前线程阻塞
●isAlive():判断当前线程是否还存活
●线程的优先级
    ●MAX PRIORITY: 10    MIN_ PRIORITY: 1   NORM PRIORITY: 5
    ●设置优先级：setpriority()
    ●获取优先级：getpriority()

三、线程的生命周期

在Thread.State中定义了线程的五种状态：NEW、RUNNABLE、BLOCKED、WAITING、TERMINATED，即一个线程完整的生命周期通常主要经历一下五种状态：

  • 新建：当一个Thread类或其子类的对象被声明并创建时，新生的线程对象处于新建状态
  • 就绪：处于新建状态的线程被start()后，将进入线程队列等待CPU时间片，此时它已具备了运行的条件，只是没分配到CPU资源
  • 运行：当就绪的线程被调度并获得CPU资源时,便进入运行状态，run()方法定义了线程的操作和功能
  • 阻塞：在某种特殊情况下，被人为挂起或执行输入输出操作时，让出CPU并临时中止自己的执行，进入阻塞状态
  • 死亡：线程完成了它的全部工作或线程被提前强制性地中止或出现异常导致结束

四、线程的同步与通信

1、线程的同步

当多个线程同时操作同个方法的时候，容易揣想那线程安全问题，比如在买票的过程中，如果多个线程同时访问当前的一张票，这样就会导致票的数量出现问题，导致线程安全问题出现，所以需要引入线程同步来解决线程安全问题，线程的同步主要有以下三种方法：

  • 通过同步代码块
Synchronized(同步监视器){
    需要被同步的代码
}
  • 通过同步方法
public synchronized void ceshi(){
    需要被同步的代码
}
  • 通过Lock锁
private ReentrantLock lock = new ReentrantLock();
public void ceshi(){
 	try{
    	lock.lock();
        需要被同步的代码
    }finally{
		lock.unlock();
    }   
}

2、线程的通信

线程的通信主要涉及三个方法：wait()、notify()、notifyAll()；此三个方法的作用为：

  • wait():一旦执行此方法，当前线程就进入阻塞状态，并释放同步监视器。

  • notify():一旦执行此方法，就会唤醒被wait的一个线程。如果有多个线程被wait，就唤醒优先级高的那个。

  • notifyAll():一旦执行此方法，就会唤醒所有被wait的线程。

五、多线程的例子：生产者消费者问题

生产者生产，消费者消费，期间容易产生线程安全问题，话不多说，直接上代码。

  • synchronized实现
public class TestProductorAndConsumer {
	public static void main(String[] args) {
		Clerk clerk = new Clerk();
		Productor pro = new Productor(clerk);
		Consumer cus = new Consumer(clerk);
		new Thread(pro, "生产者 A").start();
		new Thread(cus, "消费者 B").start();
	}
}

//店员
class Clerk{
	private int product = 0;
	//进货
	public synchronized void get(){
		while(product >= 10){//为了避免虚假唤醒问题，应该总是使用在循环中
			System.out.println("产品已满！");
			try {
				this.wait();
			} catch (InterruptedException e) {
			}
		}
		System.out.println(Thread.currentThread().getName() + " : " + ++product);
		this.notifyAll();
	}
	//卖货
	public synchronized void sale(){
		while(product <= 0){
			System.out.println("缺货！");
			try {
				this.wait();
			} catch (InterruptedException e) {
			}
		}
		System.out.println(Thread.currentThread().getName() + " : " + --product);
		this.notifyAll();
	}
}
//生产者
class Productor implements Runnable{
	private Clerk clerk;

	public Productor(Clerk clerk) {
		this.clerk = clerk;
	}

	@Override
	public void run() {
		for (int i = 0; i < 20; i++) {
			try {
				Thread.sleep(200);
			} catch (InterruptedException e) {
			}
			
			clerk.get();
		}
	}
}

//消费者
class Consumer implements Runnable{
	private Clerk clerk;

	public Consumer(Clerk clerk) {
		this.clerk = clerk;
	}

	@Override
	public void run() {
		for (int i = 0; i < 20; i++) {
			clerk.sale();
		}
	}
}
  • lock实现
public class ConsumerProductorTest {
	public static void main(String[] args) {
		Clerk clerk = new Clerk();
		Productor pro = new Productor(clerk);
		Customer cus = new Customer(clerk);
		new Thread(pro, "生產者").start();
		new Thread(cus, "消費者").start();
	}
}

class Clerk {
	private int product = 0;
	private Lock lock = new ReentrantLock();
	Condition productorlock = lock.newCondition();
	Condition customerlock = lock.newCondition();
	
	// 生产：
	public void getProduct() {
		lock.lock();
		try {
			while (product >= 10) {
				System.out.println("产品已满");
				try {
					productorlock.await();
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
			System.out.println(Thread.currentThread().getName() + ":" + ++product);
			customerlock.signalAll();
		} finally {
			lock.unlock();
		}
	}

	// 消费
	public void setProduct() {
		lock.lock();
		try {
			while (product <= 0) {
				System.out.println("缺货");
				try {
					customerlock.await();
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
			System.out.println(Thread.currentThread().getName() + ":" + product--);
			productorlock.signalAll();
		} finally {
			lock.unlock();
		}
	}
}

class Productor implements Runnable {
	private Clerk clerk;

	public Productor(Clerk clerk) {
		this.clerk = clerk;
	}

	@Override
	public void run() {
		for (int i = 0; i < 20; i++) {
			clerk.getProduct();
		}
	}
}

class Customer implements Runnable {
	private Clerk clerk;

	public Customer(Clerk clerk) {
		this.clerk = clerk;
	}

	@Override
	public void run() {
		for (int i = 0; i < 20; i++) {
			clerk.setProduct();
		}
	}
}
Boboboobo
关注
专栏目录
Java基础之多线程.md
11-10
Java多线程，Java基础，并发
多线程如何实现以及线程中常用的方法
weixin_56198901的博客
01-05 760
一，什么是线程 什么是进程 进程：正在运行的程序。系统分配资源的基本单位，如果是单核CPU，宏观上进程是并行运行，微观上串行运行。 什么是线程 线程是操作系统能够进行运算调度的最小单位。它被包含在进程之中，是进程中的实际运作单位。一条线程指的是进程中一个单一顺序的控制流，一个进程中可以并发多个线程，每条线程并行执行不同的任务。 线程，又称轻量级进程（Light Weight Process) 进程中的一条执行路径，也是CPU的基本调度单位。 一个进程由一个或多个线程组成，彼此间完成不同的工作，
java多线程1：创建线程的两种方法
qq_44182694的博客
01-22 192
创建线程 第一种：extends Thread 类 继承Thread类，重写run方法； 通过new ThreadTest（线程名字）.start()来启动线程 eg: //通过继承thread public class TreadTest extends Thread{ private int count=10; @Override public void run(){ while (true){ System.out.println(co
Java两种实现多线程方式的比较( implements Runnable 与 extends Thread )
聪少的博客
07-08 3345
1、implements Runnable 创建线程 实现步骤： (1) 定义一个线程类实现Runnable接口，重写接口中的run()方法。在run()方法中加入具体的任务代码或处理逻辑。 (2) 创建一个Thread类的对象，实现Runnable接口。 (3) 调用Thread对象的start()方法，启动线程，隐含地调用了run()方法。 例程代码： {CSDN:CODE
java 多线程之 extends Thread
比嗨皮兔
01-05 1万+
线程的实现方式 java 多线程之 extends Thread java 多线程之 implements Runnable java 多线程之 implements Callable 线程池的使用 线程池简介 ThreadPoolExecutor java 线程池之 newScheduledTh......
学习多线程，创建多线程的三种方式
weixin_45627271的博客
09-04 1702
学习多线程，创建多线程的三种方式
java基础之多线程解析
qq_50313418的博客
11-23 1188
java基础之多线程解析 下面我们通过一张图来了解一下多线程我们需要学习什么内容 程序、进程、线程 程序： 是为完成特定任务，用某种语言编写的一段代码的集合，即一段静态的代码 进程： 程序的一次执行过程或是正在运行的程序 进程作为资源分配的基本单位，系统在运行时会为每个进程分配一定的内存区域 线程： 进程可进一步细化为线程，是程序运行过程中的一条执行路径 线程作为调度和运行的最小基本单位，每个线程拥有自己独立的pc(程序计数器)和运行栈，线程切换的开销小， 可以理解为独立运行的子任
java基础之多线程的引入
weixin_50691399的博客
11-03 2623
本文主要是引入多线程
Java多线程实战-实现多线程文件下载，支持断点续传、日志记录等功能
热门推荐
qq_35716689的博客
03-10 25万+
本文将介绍如何通过Java来实现一个多线程下载器。作者：牵着猫散步的鼠鼠
JAVA零基础到高级进阶特训营 JAVA多线程并发设计+Spring高级+数据库开发+JAVA基础等
08-04
这套课程既可以作为从零基础开始...课程的主要内容涉及有JAVA基础课程、JAVA多线程与并发编程、数据库开发基础和进阶、Spring Framework、Spring进阶、Spring MVC框架、Spring boot、Java常用类库、Java异常处理等等
Java基础多线程.xmind
09-20
个人关于java基础多线程的思维导图总结。0积分下载。如果认为有帮助，请关注点赞，日后还有更多免费资源。
java多线程读取多个文件的方法
08-25
首先，本文涉及到的核心类是`Thread`类，这是Java中实现多线程的基础。在Java中，通过继承`Thread`类或者实现`Runnable`接口，可以创建一个线程。由于`Thread`类本身就是实现了`Runnable`接口的，因此这里继承`...
【C++刷题】力扣-#121-买卖股票的最佳时机
最新发布
会写代码的饭桶
10-16 328
给定一个数组 prices，其中 prices[i] 表示第 i 天的股票价格。假设你可以在第 i 天买入并在第 j 天卖出股票（i ≤ j），设计一个算法来计算你所能获取的最大利润。注意你只能持有一股股票，并且你不能同时参与多笔交易（即在再次买入前必须卖出股票）。
基于SSM班级事务管理系统的设计
2401_87849773的博客
10-15 393
管理员账户功能包括：系统首页，个人中心，学生管理，班委管理，班会组织管理，健康档案管理，党员发展管理，党员培训管理，学生成绩管理。主要技术：Java,Spring,mybatis,mysql,jquery,html。班委账号功能包括：系统首页，学生管理，学生成绩管理，活动信息管理，班费通知管理。服务器：SpringBoot自带 apache tomcat。JDK版本：Java JDK1.8。数据库可视化工具： navicat。数据库版本： mysql5.7。开发系统：Windows。
Java分布式锁
juanmiao的专栏
10-12 710
每种方法都有其优点和适应的场景，数据库通常简单，但可能存在性能问题，redis非常快，但需要第三方库，并且可能引入网诺问题，Zookeeper提供了更复杂的同步原语，但需要额外学习曲线。分布式锁的实现比线程锁和进程锁要复杂得多，因为它需要在网诺中的多个节点之间进行协调，以保证锁的唯一性和一致性。在实现分布式锁时，通常会有一个中心节点（或者称为锁服务），所有需要获取锁的节点都需要向这个中心节点申请。这个中心节点负责协调和管理所有节点的锁请求，确保锁的唯一性和一致性。创建临时节点，执行业务逻辑，释放锁。
Java安卓开发之Fragment开发（通俗易懂版）——第8章
一个脚本小子的博客
10-13 691
FragmentManager中的getSupportFragmentManager()方法不支持Activity，不论是旧版的FragmentManager还是新版的，因此我们要把继承Activity类改成继承AppCompatActivity类。
确保Spring Boot定时任务只执行一次方案
2301_76419561的博客
10-14 565
确保Spring Boot定时任务只执行一次有多种方法，你可以根据实际需求选择最适合的方法。如果你需要更复杂的任务调度或周期性执行，@Scheduled注解和接口是更合适的选择。而对于一次性的初始化任务或应用程序启动任务，注解和实现接口则更为简洁明了。
【SpringBoot的启动、处理请求整体流程（二）】
m0_50149847的博客
10-13 913
同时，如果文章有错误，也欢迎批评指正。本篇文章继之后，可以先阅读第一篇文章。
Java基础：多线程原理与创建方法详解
Java基础之多线程是计算机编程中的核心概念，尤其是在并发编程领域，它允许程序同时执行多个任务或操作，从而提高系统的效率和响应能力。本文将深入探讨Java中的多线程实现以及其重要性。 **1. 线程简介** 多线程是...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值