java学习——多线程：创建及管理

最新推荐文章于 2024-04-22 11:24:49 发布
最新推荐文章于 2024-04-22 11:24:49 发布
阅读量344 收藏 2
点赞数 1
分类专栏： JAVA基础 文章标签： 多线程 java 操作系统
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_41399650/article/details/117092802
版权

文章目录

1、多进程和多线程

进程定义：进程就是一个程序在一个数据集上的一次动态执行过程。进程一般由程序、数据集、进程控制块三部分组成。我们编写的程序用来描述进程要完成哪些功能以及如何完成；数据集则是程序在执行过程中所需要使用的资源；进程控制块用来记录进程的外部特征，描述进程的执行变化过程，系统可以利用它来控制和管理进程，它是系统感知进程存在的唯一标志。

怎么理解呢？进程就是程序的一次执行过程。比如：java中main函数执行一次呀。QQ、网易云、mysql等在运行呀之类的。

线程也叫轻量级进程，它是一个基本的CPU执行单元，也是程序执行过程中的最小单元，由线程ID、程序计数器、寄存器集合和堆栈共同组成。线程的引入减小了程序并发执行时的开销，提高了操作系统的并发性能。线程没有自己的系统资源。一个程序包含多个子任务，每个子任务可以称为一个线程，如果一个子任务阻塞,程序可以将CPU调度另外一个子任 务进行工作 这样CPU还是保留在本程序中,而不是被调 度到别的程序(进程)去 这样,提高本程序所获得CPU时间 和利用率。

线程可以理解为同一个程序不同模块:程序会出现多段代码分开执行的。多线程在通讯和协调上具有更大的优势。

进程与线程区别：

  • 一个线程只能属于一个进程，而一个进程可以有多个线程，但至少有一个线程。
  • 资源分配给进程，同一进程的所有线程共享该进程的所有资源。
  • CPU分给线程，即真正在CPU上运行的是线程。

并行、串行、并发
并行：多个CPU，每个线程分配给独立的核心，线程同步运行。

串行：单个CPU，执行完一个再执行另一个。

并发：多个线程在单个CPU上运行，同一时间一个线程运行，系统不停切换线程，看起来多个线程并行，实际上是线程不停切换。

异步与同步
在io等待的时候，同步不会切走，浪费了时间。
同步，是所有的操作都做完，才返回给用户结果。即写完数据库之后，再响应用户，用户体验不好。
异步，不用等所有操作都做完，就相应用户请求。即先响应用户请求，然后慢慢去写数据库，用户体验较好。

2、java中多线程的实现

2.1 Thread类实现

线程需要继承Thread类，实现run方法。

注意，使用start方法，程序会自动以新进程调用run方法，直接调用run方法会变成串行执行。

线程无需关闭，在run方法执行结束后会自动关闭，main函数可能早于新线程结束，程序并不终止。程序终止是等所有线程都终止。

上个简单的代码：

public class ThreadDemo1
{
	public static void main(String args[]) throws Exception
	{
		new TestThread1().start();
		while(true)
		{
			System.out.println("main thread is running");
			Thread.sleep(1000);
		}
	}
}

class TestThread1 extends Thread
{
	public void run() 
	{
		while(true)
		{
			System.out.println(" TestThread1 is running");
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
	}
}

2.2 runnable接口实现

线程需要实现Runnable接口，实现run方法。一般使用实现接口的方式来实现多线程，因为java只能单继承，继承了Thread类就不能继承其他的类了，用实现接口的方式不会出现这种问题。

注意runnable接口实现的类需要将其作为参数构建Thread类再使用start方法。同一个线程类多次start会报错，其启动的先后顺序是随机的。

上个简单的代码：

public class ThreadDemo3
{
	public static void main(String args[])
	{
		TestThread3 tt= new TestThread3();
		Thread t= new Thread(tt);
		t.start();
		while(true)
		{
			System.out.println("main thread is running");
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
	}
}
class TestThread3 implements Runnable //extends Thread
{
	public void run()
	{
		while(true)
		{
			System.out.println(Thread.currentThread().getName() +
			" is running");
			try {
				Thread.sleep(1000); 
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}
}

3、java中多线程信息共享

子线程与子线程，子线程与主线程之间需要进行交流。多线程是为了加快程序运行速度，但是不同线程之间可能会访问一些相同的资源，需要构建线程之间信息交流通讯。

java多线程中是通过共享变量达到信息共享。

传统方案，采用普通的共享变量：

  • 继承Thread类时，基于static变量。
  • 同一个Runnable类的成员变量

上述方案是不行的。

原因：
在这里插入图片描述
1、每个线程都有一个工作缓存。
线程执行过程是：

  1. 读取主存内容（正本）到工作缓存（副本）中
  2. 每个CPU执行（副本）的操作，生成结果
  3. CPU将结果写入到缓存（副本）中
  4. 数据从工作缓存（副本）刷到主存（正本）中。

所以能理解为啥传统共享变量方法不行了，从主存拿数据时拿的是一样的，但在缓存中进行数据操作之后，没法告知其他线程，原来的变量已经发生了改变。

2、多个线程对同一变量进行操作缺乏加锁限制。一窝蜂都对同一个变量进行操作，就会出错。

解决方法：

java中提供了两个关键字解决上述两个问题：

1、volatile：一旦一个变量在子线程工作缓存中修改了，其他线程也能够获取最新值。用来修饰关键字，保证不同线程对共享变量操作时的可见性。
2、synchronized：用来修饰代码块/函数，一次只能让一个线程进入，虽然加大了性能负担，但是使用简便。

举个例子：


public class ThreadDemo3 {
	public static void main(String[] args) {
		TestThread3 t = new TestThread3();
		//包装为Thread类，并且传入线程名
		new Thread(t, "Thread-0").start();
		new Thread(t, "Thread-1").start();
		new Thread(t, "Thread-2").start();
		new Thread(t, "Thread-3").start();
	}
}

class TestThread3 implements Runnable {
	private volatile int tickets = 100; // 用volatile修饰，保证不同线程对共享变量操作时的可见性。
	String str = new String("");

	public void run() {
		while (true) {
			sale();
			try {
				Thread.sleep(100);
			} catch (Exception e) {
				System.out.println(e.getMessage());
			}
			if (tickets <= 0) {
				break;
			}
		}
	}

	public synchronized void sale() { // ͬsynchronized修饰，互斥。
		if (tickets > 0) {
			System.out.println(Thread.currentThread().getName() + " is saling ticket " + tickets--);
		}
	}
}

4、java中多线程管理

4.1 线程状态

在这里插入图片描述
线程状态有：

  • new：刚创建（new）
  • runnable：就绪状态（start）
  • running：运行中（run）
  • block：阻塞状态（sleep）
  • terminaled：结束

4.2 线程协作

线程阻塞和唤醒

  • sleep。设置线程阻塞的时间，时间到了会自动醒过来。
  • wait/notify/notifyAll。等待，知道别人唤醒。
  • join。等待另一个线程结束。
  • interrupt。向另外一个线程发送中断信号,该线程收到信号,会触发InterruptedException(可解除阻塞)，并进行下一步处理。向别人发送一个信号，告诉别人，你可以停止了。需要自己去写异常处理，被动结束，可能来不及释放资源。建议采用定期检测共享变量，优雅的释放资源。

举个例子：生产者和消费者问题

 * 经典生产者与消费者问题
 * 生产者不断的往仓库中存放产品，消费者从仓库中消费产品。
 * 其中生产者和消费者都可以有若干个。
 * 仓库规则：容量有限，库满时不能存放，库空时不能取产品 。

贴代码：

package product;
/**
 * 经典生产者与消费者问题
 * 生产者不断的往仓库中存放产品，消费者从仓库中消费产品。
 * 其中生产者和消费者都可以有若干个。
 * 仓库规则：容量有限，库满时不能存放，库空时不能取产品 。
 */

public class ProductTest {
	public static void main(String[] args) throws InterruptedException {
		Storage storage = new Storage();
		
		Thread consumer1 = new Thread(new Consumer(storage));
		consumer1.setName("消费者1");
		Thread consumer2 = new Thread(new Consumer(storage));
		consumer2.setName("消费者2");
		Thread producer1 = new Thread(new Producer(storage));
		producer1.setName("生产者1");
		Thread producer2 = new Thread(new Producer(storage));
		producer2.setName("生产者2");
		
		producer1.start();
		producer2.start();
		Thread.sleep(1000);		
		consumer1.start();
		consumer2.start();		
	}
}

package product;

/**
 *仓库
 */
class Storage {
	// 仓库容量为10
	private Product[] products = new Product[10];
	private int top = 0;

	// 生产者往仓库中放入产品
	public synchronized void push(Product product) {
		while (top == products.length) {
			try {
				System.out.println("producer wait");
				wait();//仓库已满，等待
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
        //把产品放入仓库
		products[top++] = product;
		System.out.println(Thread.currentThread().getName() + " 生产了产品"
				+ product);
		System.out.println("producer notifyAll");
		notifyAll();//唤醒等待线程
		

	}

	// 消费者从仓库中取出产品
	public synchronized Product pop() {
		while (top == 0) {
			try {
				System.out.println("consumer wait");
				wait();//仓库空，等待
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}

		}

		//从仓库中取产品
		--top;
		Product p = new Product(products[top].getId(), products[top].getName());
		products[top] = null;
		System.out.println(Thread.currentThread().getName() + " 消费了产品" + p);
		System.out.println("comsumer notifyAll");
		notifyAll();//唤醒等待线程
		return p;
	}
}

package product;

import java.util.Random;

/**
 * 生产者
 */
class Producer implements Runnable {
	private Storage storage;

	public Producer(Storage storage) {
		this.storage = storage;
	}

	@Override
	public void run() {
		int i = 0;
		Random r = new Random();
		while(i<10)
		{
			i++;
			Product product = new Product(i, "电话" + r.nextInt(100));
			storage.push(product);
		}		
	}
}

package product;

/**
 * 消费者
 */
class Consumer implements Runnable {
	private Storage storage;

	public Consumer(Storage storage) {
		this.storage = storage;
	}

	public void run() {
		int i = 0;
		while(i<10)
		{
			i++;
			storage.pop();
			try {
				Thread.sleep(100);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		
	}
}

package product;

/**
 * 产品类
 */
class Product {
	private int id;// 产品id
	private String name;// 产品名称

	public Product(int id, String name) {
		this.id = id;
		this.name = name;
	}
	public String toString() {
		return "(产品ID：" + id + " 产品名称：" + name + ")";
	}
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
}

简单理解上面的内容就是：

两个生产者都开始生产，各生产10个产品。仓库只能存10个，存满了就等待，如果被消费了，就唤醒所有的生产线程。
两个消费者都开始消费，各消费10个产品。仓库产品为0个，就开始等待，如果有新的产品来了，就唤醒所有线程。

这个例子呢，其实还没有完全解释清楚notifyAll和notify怎么用的。但是这个经典的例子还是给人很多启发。包括怎么设计这种仓库存储的并发结构，经典的东西还是很值得学习。（种个草，之后写一期详解这些函数的blog哈）

再举个例子：使用interrupt暴力结束进程

package interrupt;

public class InterruptTest {

	public static void main(String[] args) throws InterruptedException {
		TestThread1 t1 = new TestThread1();
		TestThread2 t2 = new TestThread2();

		t1.start();
		t2.start();

		// 让线程运行一会儿后中断
		Thread.sleep(2000);
		t1.interrupt();
		t2.flag = false;
		System.out.println("main thread is exiting");
	}

}

class TestThread1 extends Thread {
	public void run() {
		// 判断标志，当本线程被别人interrupt后，JVM会被本线程设置interrupted标记
		while (!interrupted()) {
			System.out.println("test thread1 is running");
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				e.printStackTrace();
				break;
			}
		}
		System.out.println("test thread1 is exiting");
	}
}

class TestThread2 extends Thread {
	public volatile boolean flag = true;
	public void run() {
		// 判断标志，当本线程被别人interrupt后，JVM会被本线程设置interrupted标记
		while (flag) {
			System.out.println("test thread2 is running");
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		System.out.println("test thread2 is exiting");
	}
}

使用interrupt来打断线程，需要自己去写异常处理，被动结束，可能来不及释放资源。建议采用定期检测共享变量，优雅的释放资源。

4.3 死锁问题

为啥会出现死锁呢？

  • 每个线程互相持有别人需要的锁。
  • 预防死锁，对资源进行等级排序。

举个例子：

package deadlock;
import java.util.concurrent.TimeUnit;

public class ThreadDemo5
{
	public static Integer r1 = 1;
	public static Integer r2 = 2;
	public static void main(String args[]) throws InterruptedException
	{
		TestThread51 t1 = new TestThread51();
		t1.start();
		TestThread52 t2 = new TestThread52();
		t2.start();
	}
}
class TestThread51 extends Thread
{
	public void run() 
	{
		//先要r1,再要r2
		synchronized(ThreadDemo5.r1)
		{
			try {
				TimeUnit.SECONDS.sleep(3);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			synchronized(ThreadDemo5.r2)
			{
				System.out.println("TestThread51 is running");
			}
		}
	}
} 
class TestThread52 extends Thread
{
	public void run() 
	{
		//先要r2,再要r1
		synchronized(ThreadDemo5.r1)
		{
			try {
				TimeUnit.SECONDS.sleep(3);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			synchronized(ThreadDemo5.r2)
			{
				System.out.println("TestThread52 is running");
			}
		}
	}
}

在这里插入图片描述
查看线程状态：cmd中输入jvisualvm。

4.4 后台线程

普通线程，run方法运行结束之后才结束
守护线程，run方法运行结束或者main函数结束。

package daemon;

public class ThreadDemo4
{
	public static void main(String args[]) throws InterruptedException
	{
		TestThread4 t = new TestThread4();
		t.setDaemon(true);
		t.start();
		Thread.sleep(2000);
		System.out.println("main thread is exiting");
	}
}
 class TestThread4 extends Thread
{
	public void run() 
	{
		while(true)
		{
			System.out.println("TestThread4" + 
			"��is running");
			try {
				Thread.sleep(100);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
	}
}

守护线程永远不要访问资源，如文件或者数据库等，可能会被动结束，来不及去释放这些资源。

4.5 线程组管理

有多个Thread时，怎么把它放在一起进行管理。
缺点：

  • 能够有效管理多个线程，但是管理效率低。
  • 任务分配和执行过程高度耦合。
  • 重复创建线程，关闭线程操作，无法重用线程。
package threadgroup;

import java.util.concurrent.TimeUnit;

public class Main {

	public static void main(String[] args) {

		// 创建线程组
		ThreadGroup threadGroup = new ThreadGroup("Searcher");
		Result result=new Result();

		// 创建一个任务，10个线程完成
		Searcher searchTask=new Searcher(result);
		for (int i=0; i<10; i++) {
			Thread thread=new Thread(threadGroup, searchTask);
			thread.start();
			try {
				TimeUnit.SECONDS.sleep(1);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		System.out.println("========华丽丽0=======");
		
		// 查看线程组消息
		System.out.printf("active 线程数量: %d\n",threadGroup.activeCount());
		System.out.printf("线程组信息明细\n");
		threadGroup.list();
		System.out.println("========华丽丽1=======");

		// 遍历线程组
		Thread[] threads=new Thread[threadGroup.activeCount()];
		threadGroup.enumerate(threads);
		for (int i=0; i<threadGroup.activeCount(); i++) {
			System.out.printf("Thread %s: %s\n",threads[i].getName(),threads[i].getState());
		}
		System.out.println("========华丽丽2=======");

		// Wait for the finalization of the Threadds
		waitFinish(threadGroup);
		
		// Interrupt all the Thread objects assigned to the ThreadGroup
		threadGroup.interrupt();
	}

	public static void waitFinish(ThreadGroup threadGroup) {
		while (threadGroup.activeCount()>9) {
			try {
				TimeUnit.SECONDS.sleep(1);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}
}

package threadgroup;

import java.util.Date;
import java.util.Random;
import java.util.concurrent.TimeUnit;

public class Searcher implements Runnable {

	private Result result;
	
	public Searcher(Result result) {
		this.result=result;
	}

	@Override
	public void run() {
		String name=Thread.currentThread().getName();
		System.out.printf("Thread %s: 启动\n",name);
		try {
			doTask();
			result.setName(name);
		} catch (InterruptedException e) {
			System.out.printf("Thread %s: 被中断\n",name);
			return;
		}
		System.out.printf("Thread %s: 完成\n",name);
	}
	
	private void doTask() throws InterruptedException {
		Random random=new Random((new Date()).getTime());
		int value=(int)(random.nextDouble()*100);
		System.out.printf("Thread %s: %d\n",Thread.currentThread().getName(),value);
		TimeUnit.SECONDS.sleep(value);
	}
}

package threadgroup;

/**
 * 搜索结果类
 *
 */
public class Result {
	
	private String name;	
	public String getName() {
		return name;
	}	
	public void setName(String name) {
		this.name = name;
	}

}

在这里插入图片描述
这个不是主流的啦，先不详细看了。

总结

纯粹学习记录，希望不会误人子弟，很多内容自己目前一知半解，等我有时间再看看源码。

hhhSir'blog
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java多线程管理
antique的学习笔记
05-27 767
文章目录1，线程状态2，线程状态切换经典生产者消费者问题：3，多线程死锁4，守护（后台）线程 1，线程状态 NEW 刚创建（new） RUNNABLE 就绪态（start）：调用一个线程的start方法，那么这个线程就进入了就绪态 RUNNING 运行中（run）：等待的线程被CPU调度后就进入Running状态 BLOCK 阻塞（sleep）：由于某一个条件没有满足，暂时不需要CPU TERMINATED 结束 2，线程状态切换 线程的阻塞和唤醒 sleep：线程自我休眠，时间一到自己就会醒来
Java 中的线程是什么，如何创建和管理线程-上（十一）
Dakaring的专栏
05-01 1331
创建线程后，我们需要对线程进行管理，包括控制线程状态、线程优先级、线程同步等。Java 中的线程是基于操作系统原生线程实现的，但是 Java 提供了更为简单和方便的线程 API，使得线程的创建和管理变得更加容易。线程的管理包括控制线程状态、线程优先级、线程同步等。Java 中的线程有 6 种状态，分别是新建（NEW）、就绪（RUNNABLE）、阻塞（BLOCKED）、等待（WAITING）、计时等待（TIMED_WAITING）和终止（TERMINATED）。继承 Thread 类是一种创建线程的方式。
线程池：Java多线程的终极武器，让你的程序飞起来！
最新发布
赵KK的博客
04-22 871
线程池是Java多线程编程中的重要工具，它通过复用线程和合理管理线程资源，提高了程序的性能和响应速度。理解线程池的工作原理和核心参数，能够帮助我们更好地设计和优化多线程程序。
【多线程】线程管理
qq_48848473的博客
08-22 533
一，线程组 二，捕获线程的执行异常 三，注入Hook钩子线程
多线程--多线程的状态管理、生命周期
weixin_39213232的博客
06-26 113
线程刚被创建，但是并未启动。还没调用start方法。
java多线程（超详细）
热门推荐
zdl66的博客
08-14 10万+
进程就是正在运行中的程序（进程是驻留在内存中的）是系统执行资源分配和调度的独立单位每一进程都有属于自己的存储空间和系统资源注意：进程A和进程B的内存独立不共享。
Java进阶学习——Java多线程知识的理解
01-20
Java多线程知识的理解0.前言1.从一道题目引入2.创建线程2.1.继承Thread类2.2.实现Runnable接口3.线程的生命周期4.线程安全4.1.为什么需要线程安全？4.2.如何实现线程安全？5.线程池5.1.为什么需要线程池？5.2.创建...
Java多线程——之一创建线程的四种方法
08-26
Java多线程——之一创建线程的四种方法 Java多线程是Java编程语言中的一种重要概念，它允许程序同时执行多个任务，以提高程序的执行效率和响应速度。创建线程是Java多线程编程的基础，Java提供了四种创建线程的方法...
Java——多线程编程技术.pdf
12-31
"Java多线程编程技术.pdf" Java多线程编程技术是Java平台的一个重要技术优势，是第一个直接把跨平台线程模型和标准的内存模型集成到语言中的主流语言。多线程编程技术是Java平台的一个重要技术优势，它可以使程序的...
java上机报告5——Java的多线程编程1
08-08
Java 多线程编程应用场景 —— 电影院售票系统设计 本资源摘要信息将对 Java 多线程编程在电影院售票系统设计中的应用进行详细介绍。该系统模拟了电影院三个售票窗口同时出售电影票的过程，通过 Java 多线程编程...
Java多线程实现快速切分文件的程序
03-06
首先，我们来看标题中的核心概念——"Java多线程实现快速切分文件的程序"。这表明我们将使用Java的多线程特性来并行处理文件切分任务，以提高文件处理速度。多线程允许程序同时执行多个任务，对于大文件的处理，我们...
java 多线程超市（员工、货物）管理系统
08-13
java学习平时作业，控制台的超市货物及员工管理系统，主要是联系了服务端和客户端的socket通信以及多线程，后面也许会改成数据库及GUI实现，，，做的比较粗糙，请留言指正！！！
多线程实现与管理
qq_43750656的博客
08-20 239
线程也有自己的TID。假设有有一个存取队列的场景，有A、B两个线程，一个线程去队列中存数据，另一个线程取队列中的数据，但是取数据的线程不知道存的线程什么时候放，如果使用while去一直监听的话，这样会造成系统资源的浪费，更好的一种做法就是取线程如果获取不到数据，则进入等待状态，待存线程存入数据后 再通过取线程去获取。上述的 synchronized 锁的对象是有严重的线程安全问题的，因为每次锁的都是一个新创建出来的新对象，这个对象是刚创建出来的，对象头中的锁信息没有，则每次来一个线程都可以进入方法执行。
多线程管理
q18770158319的博客
10-20 627
文章目录前言一、线程与进程的区别二、并发和并行1、同步和异步2、并发和并行三、多线程的三个使用方法1、Thread2、Thread常用的方法3、Runnable4、Callable四、多线程的不安全的解决办法总结 前言 例如：随着计算机的不断发展，多线程这门技术也越来越重要，并且对于java来说多线程也是必须掌握的一门技术，对于我们来说是必不可少的 一、线程与进程的区别 进程：指内存中的一个应用程序，每个进程都有一个独立的内存空间，它是由多个线程组成的。 线程：指进程中的一个执行路径，共享一个内.
Java中的多线程机制
weixin_67201964的博客
11-18 1047
例如：随着人工智能的不断发展，机器学习这门技术也越来越重要，很多人都开启了学习机器学习，本文就介绍了机器学习的基础内容。提示：以下是本篇文章正文内容，下面案例可供参考如果一次只能完成一件事会很容易，但是现实生活中很多事情都是同时进行的所以Java中为了模拟这种状态，引入了线程机制。世间万物都可以同时完成很多的工作，列如，人体可以同时进行呼吸、血液循环、思考问题等活动。
多线程学习------06线程管理
Striving
07-26 475
线程管理
C# （江湖小新）- 多线程之线程池 (线程也有专门的管理部门)
qq_25702235的博客
01-03 2718
c# 多线程——ThreadPool 线程池的原理及使用
java 文件多线程
07-27
回答: 你提供的引用内容中包含了一个Java程序的代码片段，该代码片段展示了如何使用多线程进行文件下载。这段代码中，首先创建了一个`MultiThreadDownload`对象，传入了下载路径、保存路径和线程数。然后调用`download()`方法开始下载文件。\[1\] 在代码的第二个引用中，根据文件的长度计算了每个线程下载的起始位置和结束位置。通过循环遍历线程数，计算每个线程的起始位置和结束位置，并进行相应的下载操作。\[2\] 在代码的第三个引用中，首先根据访问的URL路径创建了一个`HttpURLConnection`对象，然后调用`getContentLengthLong()`方法获取文件的字节大小。接着使用`RandomAccessFile`对象调用`setLength()`方法设置本地文件的长度，这个文件是一个空数据文件，通过多线程进行对`RandomAccessFile`对象的本地文件随机位置写入数据。最后关闭文件和断开连接。\[3\] 综上所述，这段代码展示了如何使用多线程进行Java文件的下载操作，并且通过设置文件的长度和使用`RandomAccessFile`对象实现了多线程写入数据的功能。 #### 引用[.reference_title] - *1* *2* *3* [【Java】网络编程——多线程下载文件](https://blog.csdn.net/qq_42470947/article/details/105889839)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v91^control,239^v3^insert_chatgpt"}} ] [.reference_item] [ .reference_list ]

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值