java多线程

已于 2024-01-02 19:33:56 修改
阅读量94 收藏 1
点赞数 1
分类专栏： java 文章标签： java 学习 jvm
于 2023-04-24 22:12:21 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Jacksjie/article/details/130352062
版权

前言：

进程：运行中的程序的实例（例如应用程序）。

线程：进程中的执行单元。

关系：一个进程可以包含多个线程，线程是进程的一部分。

区别：

（1）进程拥有独立的内存空间和资源，而线程共享进程的内存空间和资源。

（2）进程间的切换开销较大，需要保存和恢复整个进程的上下文，而线程的切换开销较小，只需保存和恢复线程的上下文。

（3）多个线程可以并发地执行，从而提高程序的响应性能，而进程之间的并发性需要通过多进程或进程间通信来实现。

（4）线程之间共享内存，可以方便地访问共享数据，但也需要考虑线程安全问题；而进程之间的访问需要通过进程间通信进行，开销相对较大。

1.多线程实现的三种方式

 1.1 继承Thread类的方式进行实现

import java.util.Scanner;
import java.awt.*;

public class Test5 {
  public static void main(String[] args) {
	  Dage t1=new Dage("hello");
	  Dage t2=new Dage("world");
	  
	  t1.start();
	  t2.start();
  }
}
class Dage extends Thread {
    private String name;
    public Dage(String name) {
    	this.name = name;
    }
	public void run() {
		System.out.print(name+" ");
	}
}

1.2 实现Runnable接口的方式进行实现

import java.util.Scanner;
import java.awt.*;

public class Test1 {
   public static void main(String[] args) {
	  Thread t1 =new Thread(new Dage("hello"));
	  Thread t2 =new Thread(new Dage("world"));
	  
	  t1.start();
	  t2.start();
   }
}
class Dage implements Runnable {
	private String name;
	
	public Dage(String name) {
		this.name = name;
	}
	public void run() {
		System.out.print(name+" ");
	}
}

 1.3 利用Callable接口和Future接口方式实现

import java.util.Scanner;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
import java.awt.*;

public class Test5 {
  public static void main(String[] args) throws Exception {
	  Dage ge=new Dage();
	  FutureTask<String> future=new FutureTask<>(ge);
	  Thread t1=new Thread(future);
	  
	  t1.start();
	  String a=future.get();
	  System.out.println(a);
  }
}
class Dage implements Callable<String> {
    public String call() throws Exception {
    	String s="hello world";
    	return s;
    }
}

1.4 扩展写法

public class Test03 {
    public static void main(String[] args) throws InterruptedException {
        Dage t1=new Dage("hello");
        Dage t2=new Dage("world");
        t1.start();
        t2.start();
        Thread tt=new Thread(){
            @Override
            public void run() {
                System.out.print(" 匿名内部类 ");
            }

        };
        //匿名内部类
        tt.start();
        //lambda写法
        Thread ttt=new Thread(  ()->{
            System.out.println(" 学习 ");
        });
        ttt.start();
        System.out.println(" play game ");
    }
    //内部类
    static class Dage extends Thread {
        private String name;
        public Dage(String name) {
            this.name = name;
        }
        @Override
        public void run() {
            System.out.print(name+" ");
        }
    }
}

问题：

在上面三种方式中，不难发现，创建两线程的话，可能会出现打印出“world hello”的情况！，这与它们抢占CPU的情况有关，如何解决这一现象呢？

1.4 可以考虑线程的优先级，具体代码如下：

public class Test6{
    public static void main(String[] args) {
        Dage t1=new Dage("hello");
        Dage t2=new Dage("world");

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

        t1.setPriority(10);
        t2.setPriority(1);
    }
}
class Dage extends Thread {
    private String name;
    public Dage(String name) {
        this.name = name;
    }
    public void run() {
        System.out.print(name+" ");
    }
}

（说明：这样只是提高打印出“hello world"的概率但不是绝对的，所以适用性不强）

1.5 优先级不是绝对的！，那只能考虑插入线程了，具体代码如下：

public class Test6{
    public static void main(String[] args) throws InterruptedException {
        Dage t1=new Dage("hello");
        Dage t2=new Dage("world");
        t1.start();
        t1.join();
        t2.start();

    }
}
class Dage extends Thread {
    private String name;
    public Dage(String name) {
        this.name = name;
    }
    public void run() {
        System.out.print(name+" ");
    }
}

备注：这样总算解决了，多线程有许多常见的成员方法，解这个问题不限这一个方法。

2.经典多线程案例"卖火车票”

问题描述：某火车站出售100张火车票，有三个窗口在卖，请设计一个程序模拟卖票。

2.1 直接上代码（猜猜有没有问题？），代码如下：

public class Test6{
    public static void main(String[] args){
        Dage t1=new Dage();
        Dage t2=new Dage();
        Dage t3=new Dage();

        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");

        t1.start();
        t2.start();
        t3.start();
    }
}
class Dage extends Thread {
    int ticket=0;
    public void run() {
        while(true){
            if(ticket<100){
                ticket++;
                System.out.println(getName()+"正在卖第"+ticket+"张票");
            }else{
                break;
            }
        }
    }
}

问题：运行程序不难发现三个窗口竟然都卖了100张票，加起来有300张，看来这程序需要优化。

2.1 多线程加锁，具体代码如下：

public class Test6{
    public static void main(String[] args){
        Dage t1=new Dage();
        Dage t2=new Dage();
        Dage t3=new Dage();

        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");

        t1.start();
        t2.start();
        t3.start();
    }
}
class Dage extends Thread {
    static int ticket=0;
    static Object abc=new Object();
    public void run() {
        while(true) {
            synchronized (abc) {
                if (ticket < 100) {
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                    ticket++;
                    System.out.println(getName() + "正在卖第" + ticket + "张票");
                } else {
                    break;
                }
            }
        }
    }
}

2.在上面打印“hello word”的两线程中，不难发现它们之间竟然没有什么联系！，这可不符合多线程存在的意义，所以优化一下双线程，于是有了一个简单的“猜数字”游戏的程序，一个线程负责输入猜的数字，一个线程负责判断猜的情况，案例具体代码如下：

import java.util.Scanner;

public class Test4{
  public static void main(String[] args) {
  	Num n = new Num();
  	CreateThread create = new CreateThread(n);
  	JudgeThread judge = new JudgeThread(n);
  	judge.start();
  	create.start();
  }
}
// Num类完成线程之间的同步
class Num {
  int number;// 保存猜测的数
  boolean first = true;
  boolean stop = false;
}
//输入猜测的数
class CreateThread extends Thread {
  Num num;
  public CreateThread(Num num) {
  	this.num = num;
  }
  public void run(){
  	Scanner sc = new Scanner(System.in);
  	while (true) {
  		try {
  			synchronized (num) {
  				if (num.first) {// 如果是第一次执行
  					num.wait();
  				} else if (num.stop) {
  					System.out.println("猜数结束");
  					return;
  				} else {
  					System.out.print("请输入猜测的数（1-100）:");
  					int guess = sc.nextInt();
  					// 猜数结束就需要等待，判断线程
  					num.number = guess;
  					num.notify();
  					num.wait();
  				}
  			}
  		} catch (Exception e) {
  			e.printStackTrace();
  		}
  	}
  }
}
//判断线程
class JudgeThread extends Thread {
  Num num;
  public JudgeThread(Num num) {
  	this.num = num;
  }
  public void run() {
  	int random = 0;
  	while (true) {
  		try {
  			synchronized (num) {
  				if (num.first) {
  					random = (int) (Math.random() * 100 + 1);
 				//  System.out.println("产生的随机数为：" + random);
  					num.first = false;
  					num.notify();
  					num.wait();
  				} else {
  					// 判断过程
  					if (num.number < random) {
  						System.out.println("猜小了！");
  					} else if (num.number > random) {
  						System.out.println("猜大了！");
  					} else {
  						System.out.println("猜对了！");
  						num.stop = true;
  						num.notify();// 猜对结束之前
  						return;
  					}
  					num.notify();
  					num.wait();
  				}
  			}
  		} catch (Exception e) {
  			e.printStackTrace();
  		}
  	}
  }
}

3.线程池

线程池是一种多线程处理的机制，它包含了一定数量的线程，当有任务需要处理时，就从线程池中取出一个线程来处理任务。在任务处理完成后，该线程并不会立即退出，而是继续留在线程池中等待下一次任务的到来。这样可以避免频繁创建和销毁线程所带来的开销，提高了程序的效率。

线程池通常由两个部分组成：工作线程和任务队列。工作线程是线程池中的线程，它们用于执行具体的任务；任务队列是用来存储任务的队列，当有新的任务到达时，就将任务加入到队列中等待被执行。

线程池的主要优点如下：

  1. 线程复用：减少线程创建和销毁的开销，提高程序的效率；
  2. 控制并发度：通过限制线程池中的线程数量，可以有效地控制系统的并发度，避免资源竞争和阻塞；
  3. 提高响应速度：线程池可以预先创建一定数量的线程，当有任务到达时，可以立即执行，从而提高系统的响应速度。

具体原理见图解：

代码模板：

import java.util.concurrent.*;
import java.util.concurrent.atomic.AtomicInteger;
//线程池:系统的渐状性
public class Test05 {
    public static void main(String[] args) {
        //核心线程池的大小
        int corePoolSize=2;
        //核心线程池的最大数量
        int maxPoolSize=4;
        //线程最大空闲时间
        long keepAliveTime=10;
        //时间单位：秒
        TimeUnit unit=TimeUnit.SECONDS; //enum枚举，常量
        //有界阻塞队列 容量为2    最多允许放入两个空闲任务
        BlockingQueue<Runnable> workQueue=new ArrayBlockingQueue<>(2);
        // 线程创建工厂
        ThreadFactory threadFactory=new NameTreadFactory();
        //线程池拒绝策略
        RejectedExecutionHandler handler=new MyIgnorePolicy();
        ThreadPoolExecutor executor=null;
        try{
            //推荐的创建线程池的方式， 不推荐的使用现成API创创建线程池，
            executor=new ThreadPoolExecutor(corePoolSize,maxPoolSize,keepAliveTime,unit,workQueue,threadFactory,handler);
            //预启动所有核心线程 提升效率
            executor.prestartAllCoreThreads();
            //任务数量
            int count=10;
            for (int i =1; i <=count; i++) {
                RunnableTask task=new RunnableTask(String.valueOf(i));
                executor.submit(task);//提交任务到线程池 （如果任务为10，则有4个任务无法执行）
            }
        }finally {
            assert executor!=null; //断言， 可开关
            executor.shutdown();
        }
    }

    static class NameTreadFactory implements ThreadFactory{
        //线程id AtomicInteger 原子类
         private final AtomicInteger threadId=new AtomicInteger();

         @Override
         public Thread newThread(Runnable runnable){
             Thread t=new Thread(runnable,"线程"+threadId.getAndIncrement());
             System.out.println(t.getName()+"已经被创建");
             return t;
         }
    }

    public static  class MyIgnorePolicy implements RejectedExecutionHandler{
        @Override                       //被拒绝任务             线程池对象
        public  void rejectedExecution(Runnable runnable,ThreadPoolExecutor e){
            doLog(runnable,e);
        }
        private  void doLog(Runnable runnable,ThreadPoolExecutor e){
            System.err.println("线程池："+e.toString()+runnable.toString()+"被拒绝执行");
        }
    }

    //任务类
    static class  RunnableTask implements Runnable{
        private String name;
        public RunnableTask(String name){
            this.name=name;
        }
        @Override
        public void run(){
            try{
                System.out.println(this.toString()+"is running");
                Thread.sleep(3000);
            }catch (Exception e){
                e.printStackTrace();
            }
        }
        @Override
        public String toString(){
            return "RunnableTask [name="+name+"]";
        }
    }
}

T初唐四杰
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java 多线程
11-07
### Java多线程知识点详解 #### 一、Java Thread 概念 在Java中，**线程**是一种轻量级的进程，它是程序执行流的最小单元。一个标准的Java应用通常至少包含一个线程，即主（Main）线程。Java支持多线程编程，这...
多线程开发实战：Java实现多线程四种方式及相关方法原理
热门推荐
陈橘又青的博客
07-02 3万+
本文带大家了解Java实现多线程的四种方法以及实现多线程的重要注意事项和难点！
JAVA多线程【图文详解】
只有登上山顶，才能看到那边的风光
07-21 720
😽 觉得博主文章写的不错的话，希望大家三连（✌关注，✌点赞，✌评论），多多支持一下！！！
理解Java多线程及常用类的应用
Flora的博客
06-15 329
多线程
Java多线程的使用
weixin_46102505的博客
06-10 1869
多线程的简介与学习笔记
JAVA进阶学习笔记(1)：多线程
LeavingBook的博客
09-01 660
1 基本概念 1.1 程序 程序(program)是为完成特定任务、用某种语言编写的一组指令的集合。即指一段静态的代码，静态对象。 1.2 进程 进程(process)是程序的一次执行过程，或是正在运行的一个程序。是一个动态 的过程：有它自身的产生、存在和消亡的过程。——生命周期 进程作为资源分配的单位，系统在运行时会为每个进程分配不同的内存区域 。 1.3 线程 线程(thread)，进程可进一步细化为线程，是一个程序内部的一条执行路径。 1.若一个进程同一时间并行执行多个线程，就是支持多线程的 2.线程
Java多线程详解及示例
07-20
Java多线程编程是提升程序性能和响应性的关键技术。理解多线程的概念，掌握线程的创建、同步、通信、死锁避免等核心知识点，以及合理使用线程池，对于编写高效、稳定的并发程序至关重要。通过实践，开发者可以更好地...
Java多线程编程总结
01-31
要认识多线程就要从操作系统的原理说起。以前古老的DOS操作系统（V6.22）是单任务的，还没有线程的概念，系统在每次只能做一件事情。比如你在copy东西的时候不能rename文件名。为了提高系统的利用效率，采用批处理来...
Java多线程读取大文件
12-22
【Java多线程读取大文件】是一种优化的文件处理策略，特别适用于处理大型文本文件。在传统的单线程I/O操作中，读取大文件可能导致内存溢出（OOM），尤其是在尝试一次性加载整个文件到内存时。为了避免这个问题，我们...
java多线程使用详解与案例，超详细
m0_51487124的博客
08-22 2650
答：多线程同时操作同一临界资源，导致结果存在的不准确性。
Java面试篇（JVM相关专题）
聂可以的博客
08-09 2676
Java面试篇（JVM相关专题）
springboot民办高校科研项目管理系统-计算机毕业设计源码54009
VX_DZbishe的博客
08-11 309
论文主要是对基于springboot的民办高校科研项目管理系统进行了介绍，包括研究的现状，还有涉及的开发背景，然后还对系统的设计目标进行了论述，还有系统的需求以及整个的设计方案，对系统的设计以及实现，也都论述的比较细致，最后对基于springboot的民办高校科研项目管理系统进行了一些具体测试。本次报告，首先分析了研究的背景、作用、意义，为研究工作的合理性打下了基础。
SpringBoot快速入门（手动创建）
m0_74124657的博客
08-11 281
代码如下//引导类项目的入口//注解添加导入进来你可以浏览器中查看自己编写的代码，看是否正确localhost：你命名的端口号（默认是8080。后面你也可以在配置文件修改）
软件测试需要具备的基础知识【功能测试】---后端知识（三）
最新发布
yang_xs的博客
08-12 815
为了更好的学习软件测试的相关技能，需要具备一定的基础知识。需要学习的基础知识包括：1、计算机基础2、前端知识3、后端知识4、软件测试理论后期分四篇文章进行编写，这是第三篇CS架构BS架构效率：c/s效率高，某些内容已经安装在系统中了，b/s每次都要加载最新的数据升级：b/s无缝升级；c/s删除老版本再安装新版本安全：c/s更安全，需要安装、注册、登录；b/s有浏览器即可使用，安全程度低开发成本：b/s成本低；c/s需要不同的系统要不同的开发人员，成本高。
集合（1）
supercool7的博客
08-12 446
表示不同的类型集合，Collection、Map、List、Set、Queue、Deque等，以及辅助性质的接口Iterator、LinkIterator、Comparator、Comparable这些接口是为迭代和比较元素而准备。对接口的具体实现，主要常用的有：ArrayList、LinkedList、HashMap、HashSet、TreeMap等等。理解Java集合体系可以从三个层次：最上层的接口、中间的抽象类、最后的实现类。是所有集合框架的根接口，包含了对集合进行基本操作的方法。
反射和注解
supercool7的博客
08-08 275
反射的基本步骤包括获取Class对象、获取类的信息（构造函数、方法、字段等），然后通过Constructor、Method、Field等类的实例进行具体的操作。注解以@符号开头，通常紧跟着一个标识符，后面可以跟一些参数，用于给类、方法、字段等添加元数据信息，这些信息可以在编译时、运行时被读取和处理。通过Class类，可以获取类的构造函数、方法、字段等信息，而不需要在编译时确定这些信息。Spring、SpringBoot、Mybatis等框架中都大量使用了反射机制。此外，开发者还可以定义自己的注解，通过。
Java：继承，this，super
m0_75257168的博客
08-10 353
可以同名，但参数列表不能相同（有参无参构造）
安卓Android & JAVA校招/实习面试合集:多线程、强软弱虚引用、进程、内存管理、Activity、Fragment......
qq_41915623的博客
08-10 443
安卓Android、java面试资料合集：内存管理、多线程、进程、强软弱虚应用、Activity
Java多线程深度解析
"《Java多线程详解》- 汪文君" 本书是关于Java多线程编程的深度解析，作者汪文君分享了他在工作中和学习中的理解和实践经验。书中内容详细介绍了多线程的基本概念、Java对多线程的支持以及如何在实际编程中运用多...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值