精华内容
下载资源
问答
  • Java多线程实现

    千次阅读 2018-10-13 15:43:25
    在java中主要提供两种方式现实多线程,它们需要继承java.lang.Thread类或实现java.lang.Runnable接口。 继承Thread类 程序员启动一个新线程需要建立Thread实例,Thread类中常用的两个构造方法如下: Public ...

    前言

    多线程的应用使程序拥有并发运行的能力,进而实现程序的多任务作业。在java中主要提供两种方式现实多线程,它们需要继承java.lang.Thread类或实现java.lang.Runnable接口。

    继承Thread类

    程序员启动一个新线程需要建立Thread实例,Thread类中常用的两个构造方法如下:

    Public Thread(): 创建一个新的线程对象

    Public Thread(String threadName): 创建一个名称为threadName的线程对象。

    语法如下:

    Public class ThreadTest extends Thread{

    }

    完成线程对象创建后,需要重写run()方法,当一个类继承Thread类后,将实现该线程功能的代码写入run()方法中,然后同时调用Thread类中的start()方法执行线程,即调用run()方法。需要注意的是start()方法调用一个已经启动的线程,系统将抛出IllegalThreadStateException异常。

    Thread实例

    public class ThreadTest extends Thread{
    	private int count = 10;
    	public void run(){
    		while(true){
    			if(count == 0){
    				return;				
    			}
    			try{
    				Thread.sleep(10);
    			}catch(InterruptedException e){
    				e.printStackTrace();
    			}					
    			System.out.print(count+" ");
    			count--;
    		}
    	}
    }
    public class Main {
    	public static void main(String[] args) {
    		// TODO Auto-generated method stub
    		ThreadTest mytest1 = new ThreadTest();
    		ThreadTest mytest2 = new ThreadTest();
    		mytest1.start();
    		try{
    			//mytest1.join();//等待线程 mytest1先完成再继续执行mytest2线程			
    		}catch(Exception e){
    			e.printStackTrace();
    		}		
    		mytest2.start();
    	}
    }

    多线程运行效果:

    Thread.join()方法可以使一个线程等待另一个线程完成后再继续执行,在实际应用中,通常用来实现两件互斥的事务处理。加入Thread.join()线程方法控制的多线程运行效果:

    线程同步机制

    如何解决资源共享的问题呢,可以使用线程锁来实现共享资源的互斥访问。在java中提供了同步机制,可以有效防止资源冲突。

    1.使用同步块

    同步机制使用synchronized关键字

    public class ThreadTest extends Thread{
    	private int count = 10;
    	public void run(){
    		while(true){
    			//使用同步块
    			synchronized ("") {				
    				if(count > 0){
    					try{
    						Thread.sleep(10);
    					}catch(InterruptedException e){
    						e.printStackTrace();
    					}					
    					System.out.print(count+" ");
    					count--;
    				}		
    			}			
    		}
    	}
    }
    
    public class Main {
    	public static void main(String[] args) {
    		ThreadTest mytest1 = new ThreadTest();
    
    		Thread tA = new Thread(mytest1);
    		Thread tB = new Thread(mytest1);
    		Thread tC = new Thread(mytest1);
    		Thread tD = new Thread(mytest1);
    		tA.start();
    		tB.start();
    		tC.start();
    		tD.start();
    	}
    
    }

    2.使用同步方法

    同步方法就是在方法面前修饰synchronized关键字的方法,其语法如下:

    Synchronized void f(){

    }

    当某个对象调用了同步方法时,该对象上的其他同步方法必须等待该同步方法执行完毕后才能被执行。必须将每个访问共享资源的方法修饰为synchronized,否则就会出错。

    public class ThreadTest extends Thread{
    	private int count = 10;
    	public synchronized void mysyn(){		
    		if(count > 0){
    			try{
    				Thread.sleep(10);
    			}catch(InterruptedException e){
    				e.printStackTrace();
    			}					
    			System.out.print(count+" ");
    			count--;
    		}		
    
    	}
    	public void run(){
    		while(true){
    			mysyn();
    		}
    	}
    }
    
    public class Main {
    	public static void main(String[] args) {
    		ThreadTest mytest1 = new ThreadTest();
    
    		Thread tA = new Thread(mytest1);
    		Thread tB = new Thread(mytest1);
    		Thread tC = new Thread(mytest1);
    		Thread tD = new Thread(mytest1);
    		tA.start();
    		tB.start();
    		tC.start();
    		tD.start();
    	}
    }

    多线程未加同步控制时的运行效果,可见其资源访问存在竞争(答应输出到了负数,显然不符合程序设计需求):

    多线程加同步控制运行效果:

    总结

    多线程是轻量级的多进程实现,在节省系统资源开支的同时,实现了程序的并发运行,使得软件能够多任务执行。但是在多线程应用中,需要考虑到线程的同步,共享资源竞争等问题,线程锁可以实现线程的同步互斥,但使用不当可能引起死锁现象,故应当合理正确使用线程锁。

    展开全文
  • java多线程和spring多线程实现

    千次阅读 2018-04-02 16:37:18
    java多线程和spring多线程实现 线程thread 线程的创建方法: 1、继承Thread类创建新的可执行线程 class PrimeThread extends Thread { long minPrime; PrimeThread(long minPrime) { this.minPrime = ...

    java多线程和spring多线程实现


    线程thread

    线程的创建方法:
    1、继承Thread类创建新的可执行线程

    class PrimeThread extends Thread {
        long minPrime;
        PrimeThread(long minPrime) {
            this.minPrime = minPrime;
        }
    
        public void run() {
            // compute primes larger than minPrime
            ...
        }
    }
    
    PrimeThread p = new PrimeThread(143);
    p.start();

    2、创建一个实现Runnable接口的类,该类必须实现run方法。这个实现类的实例可以作为创建Thread的入参,从而创建新的可执行线程

    class PrimeRun implements Runnable {
        long minPrime;
        PrimeRun(long minPrime) {
            this.minPrime = minPrime;
        }
    
        public void run() {
            // compute primes larger than minPrime
            ...
        }
    }
    
    
    PrimeRun p = new PrimeRun(143);
    new Thread(p).start();

    注:实际上 ,Thread类是Runnable的一个实现类,通过jdk源码可以看出


    从java 1.5版本之后,使用java并发工具包java.util.concurrent
    3、Callable接口、ExecutorService接口和Future接口实现有返回结果的线程
    Callable接口与Runnable类似,Runnable无返回结果;ExecutorService接口是Executor接口的拓展

    public class MyCallable implements Callable<Object>{
        private String taskName;
        MyCallable(String taskName) {
            this.taskName = taskName;
        }
        @Override
        public Object call() throws Exception {
            return taskName;
        }
    }
    
    int poolSize = 10;
    // 创建大小为10的 线程池
    ExecutorService pool = Executors.newFixedThreadPool(poolSize);
    // 创建任务
    List<Future> taskList = new ArrayList<Future>();
    for (int i = 0; i < taskSize; i++) {
        Callable c = new MyCallable("task "+i);
        // 执行任务并获取Future对象
        Future f = pool.submit(c);
        // 添加到任务列表
        taskList.add(f);
    }
    // 关闭线程池
    pool.shutdown();
    
    // 获取所有并发任务的运行结果
    for (Future f : taskList) {
        // 从Future对象上获取任务的返回值,并输出到控制台
        try {
            // 通过f.get()获得返回结果 ,do something
            ...
        }catch (Exception e){
            // 错误处理
            ...
        }
    }

    4、FutureTask类和Callable接口实现线程
    FutureTask是一个包装类,它同时实现了Future和Runnable接口,可以通过Callable实例来创建

    public class MyCallable implements Callable<Object>{
        private String taskName;
        MyCallable(String taskName) {
            this.taskName = taskName;
        }
        @Override
        public Object call() throws Exception {
            return taskName;
        }
    }
    
    Callable c = new MyCallable("my task");
    FutureTask<String> oneTask = new FutureTask<String>(c);
    Thread cThread = new Thread(oneTask);
    cThread.start();

    Spring boot多线程

    在spring的项目中,由于Bean对象是spring容器管理,我们可以自定义一个类,然后注册成bean的方式使用java多线程,比如我们使用上面第3种方法

    MyCallable.class

    import java.util.concurrent.Callable;
    
    public class MyCallable implements Callable<Object>{
        private String taskName;
        MyCallable(String taskName) {
            this.taskName = taskName;
        }
        @Override
        public Object call() throws Exception {
            return taskName;
        }
    }

    TaskService.class

    import org.springframework.stereotype.Service;
    import java.util.concurrent.*;
    
    @Service
    public class TaskService {
        ExecutorService executorService;
        private int taskSize = 10;
    
        public TaskService() {
            if (executorService == null) {
                executorService = Executors.newFixedThreadPool(taskSize);
            }
        }
    
        public void execute(Runnable r) {
            executorService.execute(r);
        }
    
        public <T> Future<T> submit(Callable<T> task) {
            return executorService.submit(task);
        }
    }

    这里直接使用测试方法
    TaskServiceTest.class

    import org.junit.Test;
    import org.springframework.beans.factory.annotation.Autowired;
    
    import java.util.ArrayList;
    import java.util.List;
    import java.util.concurrent.Callable;
    import java.util.concurrent.Future;
    
    /**
     * demo test
     */
    public class TaskServiceTest extends BaseTest {
        @Autowired
        private TaskService taskService;
    
        @Test
        public void main(){
            List<Future> list = new ArrayList<Future>();
            for (int i = 0; i < 10; i++) {
                Callable c = new MyCallable("task "+i);
                // 执行任务并获取Future对象
                Future f = taskService.submit(c);
                list.add(f);
            }
    
            // 获取所有并发任务的运行结果
            for (Future f : list) {
                // 从Future对象上获取任务的返回值,并输出到控制台
                try {
                    System.out.println(f.get().toString());
                }catch (Exception e){
                    e.printStackTrace();
                }
            }
        }
    }
    展开全文
  • Java多线程实现方式

    千次阅读 2018-04-16 18:56:27
    Java多线程实现方式 Java多线程实现方式 实现方式 不同实现方式的差异 实现方式 Java多线程共有四种不同的实现方式:分别为继承Thread类、实现Runnable接口,实现Callable接口 并...

    实现方式

    Java多线程共有四种不同的实现方式:分别为继承Thread类、实现Runnable接口,实现Callable接口并通过FutureTask包装器创建线程,使用ExecutorService、Callable、Future实现多线程。

    继承Thread类实现多线程

    Thread类本质上实现了Runnable接口,代表一个线程的实例。启动线程的唯一方法是调用类的start方法。start方法是一个native方法,它将启动一个新线程,并执行run方法。

    以这种方式实现多线程较为简单:首先定义自己的类,然后自己的类继承Thread类,并重写run()方法,调用start方法就可以启动一个新线程并执行run方法。示例如下:

    public class ThreadDemo extends Thread{
    	public void run(){
    		System.out.println("ThreadDemo start..");
    	}
    
    	public static void main(String[] args) {
    		ThreadDemo td = new ThreadDemo();
    		td.start();
    	}
    }
    

    实现Runnable接口实现多线程。示例如下:

    public class RunnableDemo implements Runnable{
    	@Override
    	public void run() {
    		System.out.println("RunnableDemo start..");
    	}
    
    	public static void main(String[] args) {
    		RunnableDemo rd = new RunnableDemo();
    		Thread t = new Thread(rd);
    		t.start();
    	}
    }
    

    实现Callable接口并通过FutureTask包装器创建线程。示例如下:

    public class CallableDemo{
    	public static void main(String[] args) throws InterruptedException, ExecutionException {
    		Callable<Integer> call = new Callable<Integer>() {
                @Override
                public Integer call() throws Exception {
                    System.out.println("callable thread start..");
                    Thread.sleep(2000);
                    return 1;
                }
            };
    
            FutureTask<Integer> task = new FutureTask<>(call);
            Thread t =  new Thread(task);
            t.start();
       
            System.out.println("do other thing..");
            System.out.println("callable res=" + task.get());
    	}
    }
    

    使用ExecutorService、Callable、Future实现多线程。示例如下:

    public class ExecutorServiceDemo {
    	public static void main(String[] args) throws InterruptedException, ExecutionException {
    		System.out.println("main start..");
    		int taskSize = 5;
    
    		ExecutorService pool = Executors.newFixedThreadPool(taskSize);
    		List<Future<Integer>> list = new ArrayList<Future<Integer>>();
    		for (int i = 0; i < taskSize; i++) {
    			Callable<Integer> c = new MyCallable<Integer>(i + " ");
    			Future<Integer> f = pool.submit(c);
    			list.add(f);
    		}
    
    		pool.shutdown();
    
    		for (Future<Integer> f : list) {
    			System.out.println("threads res=" + f.get());
    		}
    	}
    }
    
    class MyCallable<Integer> implements Callable<Integer> {
    	private String taskNum;
    
    	MyCallable(String taskNum) {
    		this.taskNum = taskNum;
    	}
    
    	public Integer call() throws Exception {
    		System.out.println("---" + taskNum + " thread start");
    		Date dateStart = new Date();
    		Thread.sleep(1000);
    		Date dateEnd = new Date();
    		long time = dateEnd.getTime() - dateStart.getTime();
    		return (Integer) (taskNum + " end require[" + time + "ms]");
    	}
    }
    

    不同实现方式的差异

    • 如果自己定义的类已经继承了其他类,由于java是单根继承,故只能通过实现接口实现多线程。
    • 继承Thread类和实现Runnable接口实现多线程,没有返回值;实现Callable接口和利用ExecutorService实现多线程可以有返回值,并封装与FutureTask和Future中,值得注意的是,获取返回值的get方法,是阻塞方法,即必须等到线程执行结束才能得到返回值。
    • 继承Thread类和实现Runnable接口实现多线程,不能抛出异常;实现Callable接口和利用ExecutorService
      实现多线程,可以抛出异常。
    展开全文
  • 1.章节结构图 ...多线程编程一方面有助于提高系统吞吐量、提高系统的响应性、充分利用多核处理器、最小化对系统资源的使用和简化程序的结构;另一方面面临线程安全、线程活性、上下文切换和可靠性等问题 ...

    1.章节结构图

    2. 详细描述

    • 进程是程序的运行实例,一个进程可包含多个线程,他们都共享所在进程的资源;
    • 应用程序负责创建线程与启动线程,线程调度器负责线程的调度与执行;
    • 线程是多线程编程的基本单位。多线程编程一方面有助于提高系统吞吐量、提高系统的响应性、充分利用多核处理器、最小化对系统资源的使用和简化程序的结构;另一方面面临线程安全、线程活性、上下文切换和可靠性等问题
    展开全文
  • 实现多线程的几种方式,建议使用runable实现,不管如何最终都需要thread.start( )来启动线程。
  • 万字图解Java多线程

    万次阅读 多人点赞 2020-09-06 14:45:07
    java多线程我个人觉得是javaSe中最难的一部分,我以前也是感觉学会了,但是真正有多线程的需求却不知道怎么下手,实际上还是对多线程这块知识了解不深刻,不知道多线程api的应用场景,不知道多线程的运行流程等等,...
  • 需求中需要查询多个SQL...但是使用并行的方式进行查询,即多线程查询,所消耗的时间为查询最久SQL的时间。 此处使用callable + furtherTask 方式实现 Callable<List<Map<String, String>>> ma...
  • Java多线程实现复制文件

    千次阅读 2018-09-24 15:55:33
    * 多线程实现文件从一个目录复制到另一个目录 * @param sourceFile:给定源文件路径名 * @param desPath:复制点文件路径 * @return */ 代码实现如下: package com.tulun.thread; import java.io.File; import...
  • Java多线程实现多用户与服务端Socket通信

    千次阅读 多人点赞 2020-11-02 13:54:36
    Java多线程实现多用户与服务端Socket通信,类似QQ、微信、视频等客户端,多用户与服务器通信。详细记录服务端多线程的实现,目标是多用户(客户端)能够同时与服务器建立连接并通信,避免阻塞,进一步完善TCP的...
  • Java多线程

    万次阅读 多人点赞 2021-06-11 16:28:49
    Java多线程Java多线程线程的创建线程常见方法线程的状态线程的优先级守护线程线程组Java线程池线程池的创建线程池的参数线程池的使用线程不安全问题Java中的锁synchronized同步方法synchronized同步语句块...
  • JAVA多线程实现的三种方式

    千次阅读 2016-08-25 10:43:23
    JAVA多线程实现方式主要有三种:继承Thread类、实现Runnable接口、使用ExecutorService、Callable、Future实现有返回结果的多线程。其中前两种方式线程执行完后都没有返回值,只有最后一种是带返回值的。 2.继承...
  • JAVA多线程实现的四种方式

    千次阅读 2018-06-19 18:44:40
    Java多线程实现方式主要有四种:继承Thread类、实现Runnable接口、实现Callable接口通过FutureTask包装器来创建Thread线程、使用ExecutorService、Callable、Future实现有返回结果的多线程。   其中前两种方式...
  • Java 多线程:彻底搞懂线程池

    万次阅读 多人点赞 2019-07-09 19:27:00
    熟悉Java多线程编程的同学都知道,当我们线程创建过多时,容易引发内存溢出,因此我们就有必要使用线程池的技术了。 目录 1 线程池的优势 2 线程池的使用 3 线程池的工作原理 4 线程池的参数 4.1 任务队列...
  • Java多线程实现的四种方式

    万次阅读 多人点赞 2017-07-19 01:45:07
    Java多线程实现的方式有四种 1.继承Thread类,重写run方法 2.实现Runnable接口,重写run方法,实现Runnable接口的实现类的实例对象作为Thread构造函数的target 3.通过Callable和FutureTask创建线程 4.通过线程池创建...
  • java多线程编程】三种多线程实现方式

    万次阅读 多人点赞 2019-01-01 16:20:56
    文章目录前言进程与线程继承Thread类,实现多线程FAQ 为什么多线程的启动不直接使用run()方法而必须使用Thread类中start()方法呢?...在java语言最大的特点是支持多线程的开发(也是为数不多...
  • 一、在java中怎样实现多线程? extends Thread implement Runnable 方法一:继承 Thread 类,覆盖方法 run(),我们在创建的 Thread 类的子类中重写 run() ,加入线程所要执行的代码即可。 下面是一个例子:...
  • Java多线程之初识线程

    万次阅读 2020-09-10 23:49:26
    文章目录实现多线程的两种方式区别继承Thread示例实现Runnable接口示例start()的执行步骤 实现多线程的两种方式 1、继承Thread类; 2、实现Runnable接口。 区别 Java语言是单继承的,使用实现Runnable方式创建线程,...
  • Java多线程实现下载功能

    万次阅读 2012-11-22 11:38:19
    网上找了份资料,是别人完成的Java实现多线程下载的功能。 Java多线程的好处挺多的,可以充分利用CPU的资源,简化编程模型,简化异步事件的处理,使GUI更有效率,节约成本。 下面是实现多线程下载的代码: package ...
  • java多线程以及java网络编程实现简单的聊天系统

    千次阅读 热门讨论 2015-10-15 20:57:04
    该系统采用java多线程技术及java网络编程技术实现一个基于C/S的聊天系统,系统分为客户端及服务器端: 服务器端主要涉及到以下几个线程: 1.在服务器启动之后会启动一个名为ConnectThread的线程,该线程用来处理...
  • Java多线程实现龟兔赛跑

    千次阅读 2019-09-08 14:41:11
    题目描述: 乌龟和兔子进行1000米赛跑,兔子前进5米,乌龟只能前进1米,但兔子每20米要...代码实现: package com.yrf.myjava.ch01; import java.lang.Thread; import java.lang.Runnable; class Rabbit imple...
  • JAVA多线程实现方式主要有三种:继承Thread类、实现Runnable接口、使用ExecutorService、Callable、Future实现有返回结果的多线程。其中前两种方式线程执行完后都没有返回值,只有最后一种是带返回值的。 1、继承...
  • ExecutorService实现java多线程

    千次阅读 2014-11-06 11:38:55
    Java5之后,并发线程这块发生了根本的变化,最重要的莫过于新的启动、调度、管理线程的一大堆API了。在Java5以后,通过Executor来启动线程比用Thread的start()更好。在新特征中,可以很容易控制线程的启动、执行和...
  • java多线程实现抢票

    千次阅读 2019-06-06 10:15:47
    多线程抢票 就是对一个公共的资源进行修改的操作,在这过程中可能会发生线程安全问题: 可以通过线程同步 和lock锁来保证线程的同步。 package com.baidu.dosometest; import java.util.concurrent.locks....
  • Java多线程实现售票系统

    千次阅读 2019-08-12 20:18:43
    学习多线程比较经典的案例就是实现售票系统了。 我们先来看看需求:铁道部发布了一个售票任务,要求销售100张票,要求有5个窗口来进行销售,效果如下: 窗口001正在销售第100张票 窗口001正在销售第99张票 窗口...
  • JAVA多线程实现龟兔赛跑

    万次阅读 2017-10-13 09:18:05
    要求 1、兔子每秒跑5米,但是每10米要休息2秒 2、乌龟每秒钟4米,不休息 3、谁先到达终点,比赛结束 ...import java.util.concurrent.CyclicBarrier; import java.util.concurrent.ExecutorService; publ
  • java 多线程实现的四种方式

    千次阅读 2018-08-29 11:13:07
    一个线程的生命周期 线程是一个动态执行的过程,它也有一个从产生到死亡的过程。 下图显示了一个线程完整的生命周期。 新建状态: 使用 new 关键字和 Thread 类或其子类建立一个线程对象后,该线程对象就...
  • Java多线程如何实现

    千次阅读 2018-06-10 20:00:20
    Java多线程Java高级特性之一,通过多线程,我们可以实现多任务同时协同工作,在一定情况下提升程序效率,但是Java多线程仍要慎重使用,首先第一点,Java多线程需要较高的编码技巧,一旦使用不当就会造成程序错误,...
  • Java 多线程实现多个窗口同时卖票

    千次阅读 2016-05-08 20:34:05
    Java 多线程实现多个窗口同时卖票

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 898,488
精华内容 359,395
关键字:

多线程实现java

java 订阅