用Java实现多线程

最新推荐文章于 2020-10-08 15:48:45 发布
最新推荐文章于 2020-10-08 15:48:45 发布
阅读量318 收藏
点赞数
分类专栏： 操作系统 Java 文章标签： 多线程 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u012340794/article/details/61205412
版权

本文部分学习和参考了这篇文章：http://blog.csdn.net/evankaka/article/details/44153709#t2

之前学习了关于进程和线程的理论知识，但是关于他们是怎么实现的，还缺乏实践。这两天学习了一些关于Java实现多线程的知识，特此总结一下。目前所学知识多线程中很小的一部分，还会持续更新。想了解进程与线程知识可以参看我的这篇文章：漫谈进程与线程。

一般来说，Java实现多线程的方式有两种：继承java.lang.Thread类，实现java.lang.Runnable接口。

1、继承Thread类

一个类可以通过继承Thread类来实现多线程，这是一种比较常见的方法(但并不是一种推荐的方法)。继承之后可以重载其run()方法，看下面的例子： 
package com.multiThread.learning;


/**
 * multi thread example 1
 * @author nelson
 *
 */
public class Thread1 extends Thread{
	private String name;
	public Thread1(String s) {
		this.name = s;
	}
	
	@Override
	public void run() {
		for(int i=0; i<5; i++){
			System.out.println(name + " is running=======" + i);
			try {
				sleep((int)Math.random()*10);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}

	public static void main(String[] args) {
		Thread1 t1 = new Thread1("A");
		Thread1 t2 = new Thread1("B");
		t1.start();
		t2.start();
	}

}

//输出信息
/*
A is running=======0
B is running=======0
A is running=======1
A is running=======2
A is running=======3
A is running=======4
B is running=======1
B is running=======2
B is running=======3
B is running=======4
*/
从程序运行的结果可以发现，多线程程序是乱序执行。这是因为start()方法的调用后并不是立即执行多线程代码，而是使得该线程变为可运行态（Runnable），什么时候运行是由操作系统决定的。
Thread.sleep()方法调用目的是不让当前线程独自霸占该进程所获取的CPU资源，以留出一定时间给其他线程执行的机会。
上诉代码每次运行的结果都可能不一样。
但是start方法重复调用的话，会出现java.lang.IllegalThreadStateException异常。

2、实现java.lang.Runnable接口

采用Runnable也是非常常见的一种，我们只需要重写run方法即可。下面也来看个实例 
package com.multiThread.learning;

public class Thread2 implements Runnable{
	private String name;

	public static void main(String[] args) {
		Thread2 t1 = new Thread2("C");
		Thread2 t2 = new Thread2("D");
		new Thread(t1).start();
		new Thread(t2).start();

	}
	
	public Thread2(String inputName) {
		this.name = inputName;
	}
	
	@Override
	public void run() {
		for(int i=0; i<5; i++){
			System.out.println(name + " is running=======" + i);
			try {
				Thread.sleep((int)Math.random()*10);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		
	}

}
/*
输出结果
C is running=======0
D is running=======0
C is running=======1
D is running=======1
D is running=======2
D is running=======3
D is running=======4
C is running=======2
 */
说明：
Thread2类通过实现Runnable接口，使得该类有了多线程类的特征。run()方法是多线程程序的一个约定。所有的多线程代码都在run方法里面。Thread类实际上也是实现了Runnable接口的类。
在启动的多线程的时候，需要先通过Thread类的构造方法Thread(Runnable target) 构造出对象，然后调用Thread对象的start()方法来运行多线程代码。
实际上所有的多线程代码都是通过运行Thread的start()方法来运行的。因此，不管是扩展Thread类还是实现Runnable接口来实现多线程，最终还是通过Thread的对象的API来控制线程的

3、两种方式对比

实现Runnable接口比继承Thread类所具有的优势：
  1. 适合多个相同的程序代码的线程去处理同一个资源
  2. 可以避免java中的单继承的限制
  3. 增加程序的健壮性，代码可以被多个线程共享，代码和数据独立
  4. 线程池只能放入实现Runable或callable类线程，不能直接放入继承Thread的类
关于资源共享，继承Thread虽然也能实现，但是却比Runnable麻烦，目前先不研究怎样通过Thread实现资源共享。将上诉例子做修改，看看Runnable如何实现的。 
package com.multiThread.learning;


/**
 * 
 * @author nelson
 *
 */
public class Thread1 extends Thread{
	private String name;
	private int num = 5;
	public Thread1(String s) {
		this.name = s;
	}
	
	@Override
	public void run() {
		for(int i=0; i<5; i++){
			//System.out.println(name + " is running=======" + i);
			System.out.println(this.name + " 当前的num是：" + this.num--);
			try {
				sleep((int)Math.random()*10);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}

	public static void main(String[] args) {
		Thread1 t1 = new Thread1("A");
		Thread1 t2 = new Thread1("B");
		t1.start();
		t2.start();
	}

}
/*
 * 运行结果
A 当前的num是：5
B 当前的num是：5
A 当前的num是：4
B 当前的num是：4
A 当前的num是：3
B 当前的num是：3
A 当前的num是：2
B 当前的num是：2
A 当前的num是：1
B 当前的num是：1
 */
package com.multiThread.learning;

public class Thread2 implements Runnable{
	private String name;
	private int num = 5;

	public static void main(String[] args) {
		Thread2 t1 = new Thread2("C");
		Thread2 t2 = new Thread2("D");
		new Thread(t1).start();
		new Thread(t2).start();

	}
	
	public Thread2(String inputName) {
		this.name = inputName;
	}
	
	@Override
	public void run() {
		for(int i=0; i<5; i++){
			//ystem.out.println(name + " is running=======" + i);
			System.out.println(this.name + " 当前的num是：" + this.num--);
			try {
				Thread.sleep((int)Math.random()*10);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		
	}
/*
 *输出结果
C 当前的num是：5
D 当前的num是：5
D 当前的num是：4
D 当前的num是：3
D 当前的num是：2
D 当前的num是：1
C 当前的num是：4
C 当前的num是：3
C 当前的num是：2
C 当前的num是：1
 */
}

package com.multiThread.learning;

public class Thread2 implements Runnable{
	private String name;
	private int num = 5;

	public static void main(String[] args) {
		Thread2 t1 = new Thread2("C");
		new Thread(t1).start();
		new Thread(t1).start();

	}
	
	public Thread2(String inputName) {
		this.name = inputName;
	}
	
	@Override
	public void run() {
		for(int i=0; i<5; i++){
			//ystem.out.println(name + " is running=======" + i);
			System.out.println("ID:" + Thread.currentThread().getId() + " 当前的num是：" + this.num--);
			try {
				Thread.sleep((int)Math.random()*10);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		
	}
/*
 *输出结果
ID:10 当前的num是：5
ID:11 当前的num是：4
ID:10 当前的num是：3
ID:10 当前的num是：1
ID:10 当前的num是：0
ID:10 当前的num是：-1
ID:11 当前的num是：2
ID:11 当前的num是：-2
ID:11 当前的num是：-3
ID:11 当前的num是：-4
 */
}
从上面这几个程序可以看出，Runnable可以通过给不同的Thread赋同一个实体类，来实现资源共享

4、常用函数

1、join()方法：等待某一线程终止。在很多情况下，主线程生成并起动了子线程，如果子线程里要进行大量的耗时的运算，主线程往往将于子线程之前结束，但是如果主线程处理完其他的事务后，需要用到子线程的处理结果，也就是主线程需要等待子线程执行完成之后再结束，这个时候就要用到join()方法了。看下面两个例子
没有用join()的情况： 
package com.multiThread.learning;

class JoinThread implements Runnable{
	private String name;
	
	public JoinThread(String inputName) {
		this.name = inputName;
	}

	@Override
	public void run() {
		System.out.println(Thread.currentThread().getName() + "开始运行！");
		for(int i=0; i<5; i++){
			System.out.println(Thread.currentThread().getName() + "===" + i);
			try {
				Thread.sleep((int)Math.random()*10);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
		
		System.out.println(Thread.currentThread().getName() + "运行结束！");
		
	}
	
}

public class JoinTest {
	
	

	public static void main(String[] args) {
		System.out.println("主线程开始运行！");
		JoinThread j1 = new JoinThread("A");
		JoinThread j2 = new JoinThread("B");
		new Thread(j1).start();
		new Thread(j2).start();
		System.out.println("主线程结束运行！");
	}

/*
 * 输出结果
主线程开始运行！
主线程结束运行！
Thread-1开始运行！
Thread-0开始运行！
Thread-1===0
Thread-0===0
Thread-1===1
Thread-0===1
Thread-1===2
Thread-0===2
Thread-1===3
Thread-0===3
Thread-1===4
Thread-0===4
Thread-1运行结束！
Thread-0运行结束！
 */
}

加入join()方法： 
package com.multiThread.learning;

class JoinThread implements Runnable{
	private String name;
	
	public JoinThread(String inputName) {
		this.name = inputName;
	}

	@Override
	public void run() {
		System.out.println(Thread.currentThread().getName() + "开始运行！");
		for(int i=0; i<5; i++){
			System.out.println(Thread.currentThread().getName() + "===" + i);
			try {
				Thread.sleep((int)Math.random()*10);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
		
		System.out.println(Thread.currentThread().getName() + "运行结束！");
		
	}
	
}

public class JoinTest {

	public static void main(String[] args) {
		System.out.println("主线程开始运行！");
		JoinThread j1 = new JoinThread("A");
		JoinThread j2 = new JoinThread("B");
		Thread t1 = new Thread(j1);
		Thread t2 = new Thread(j2);
		t1.start();
		t2.start();
		try {
			t1.join();
			t2.join();
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		System.out.println("主线程结束运行！");
	}

/*
 * 输出结果
主线程开始运行！
Thread-1开始运行！
Thread-1===0
Thread-0开始运行！
Thread-0===0
Thread-1===1
Thread-1===2
Thread-1===3
Thread-1===4
Thread-0===1
Thread-1运行结束！
Thread-0===2
Thread-0===3
Thread-0===4
Thread-0运行结束！
主线程结束运行！
 */
}
不难发现，在加入join()方法后，主线程会等子线程运行完毕后再接着运行。

2、暂停当前正在执行的线程对象，并执行其他线程。yield()应该做的是让当前运行线程回到可运行状态，以允许具有相同优先级的其他线程获得运行机会。因此，使用yield()的目的是让相同优先级的线程之间能适当的轮转执行。但是，实际中无法保证yield()达到让步目的，因为让步的线程还有可能被线程调度程序再次选中。看下面例子 
package com.multiThread.learning;

public class YieldTest {

	public static void main(String[] args) {
		Thread2 t1 = new Thread2("C");
		Thread2 t2 = new Thread2("D");
		new Thread(t1).start();
		new Thread(t2).start();
	}

}

class YieldThread implements Runnable{
	private String name;
	
	public YieldThread(String inputName) {
		this.name = inputName;
	}

	@Override
	public void run() {
		for(int i=0; i<6; i++){
			System.out.println(name + "===" + i);
			if(i == 3){
				Thread.yield();
			}
		}
		
	}
}
这段程序可以使一个线程运行到i=3时，暂时让出cpu。
3、sleep()方法:使当前线程进入停滞状态（阻塞当前线程），让出CUP的使用，目的是不让当前线程独自霸占该进程所获的CPU资源，以留一定时间给其他线程执行的机会;
　　 sleep()是Thread类的Static(静态)的方法；因此他不能改变对象的机锁，所以当在一个Synchronized块中调用Sleep()方法是，线程虽然休眠了，但是对象的机锁并木有被释放，其他线程无法访问这个对象（即使睡着也持有对象锁）。
　　在sleep()休眠时间期满后，该线程不一定会立即执行，这是因为其它线程可能正在运行而且没有被调度为放弃执行，除非此线程具有更高的优先级。 
4、wait（）方法。wait()方法是Object类里的方法；当一个线程执行到wait()方法时，它就进入到一个和该对象相关的等待池中，同时失去（释放）了对象的机锁（暂时失去机锁，wait(long timeout)超时时间到后还需要返还对象锁）；其他线程可以访问；
　　wait()使用notify或者notifyAlll或者指定睡眠时间来唤醒当前等待池中的线程。
　　wiat()必须放在synchronized block中，否则会在program runtime时扔出”java.lang.IllegalMonitorStateException“异常。
5、sleep()和yield()的区别
        sleep()使当前线程进入停滞状态，所以执行sleep()的线程在指定的时间内肯定不会被执行；yield()只是使当前线程重新回到可执行状态，所以执行yield()的线程有可能在进入到可执行状态后马上又被执行。
        sleep 方法使当前运行中的线程睡眼一段时间，进入不可运行状态，这段时间的长短是由程序设定的，yield 方法使当前线程让出 CPU 占有权，但让出的时间是不可设定的。实际上，yield()方法对应了如下操作：先检测当前是否有相同优先级的线程处于同可运行状态，如有，则把 CPU  的占有权交给此线程，否则，继续运行原来的线程。所以yield()方法称为“退让”，它把运行机会让给了同等优先级的其他线程
       另外，sleep 方法允许较低优先级的线程获得运行机会，但 yield()  方法执行时，当前线程仍处在可运行状态，所以，不可能让出较低优先级的线程些时获得 CPU 占有权。在一个运行系统中，如果较高优先级的线程没有调用 sleep 方法，又没有受到 I\O 阻塞，那么，较低优先级线程只能等待所有较高优先级的线程运行结束，才有机会运行。 
6、sleep()和wait()的区别：两者最大的区别是sleep()不释放资源，而wait()会释放资源。

5、CyclicBarrier

CyclicBarrier是一个线程计数器，初始化时规定一个数目，然后计算调用了CyclicBarrier.await()进入等待的线程数。当线程数达到了这个数目时，所有进入等待状态的线程被唤醒并继续。
CyclicBarrier初始时还可带一个Runnable的参数， 此Runnable任务在CyclicBarrier的数目达到后，所有其它线程被唤醒前被执行。
看如下例子： 
package com.multiThread.learning;

import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;

public class CyclicBarrierTest {
	private static final int THREAD_NUM = 5;
	public static void main(String[] args){
		
		CyclicBarrier cb = new CyclicBarrier(THREAD_NUM, new Runnable() {
			
			@Override
			public void run() {
				System.out.println("when do I execute?");
				
			}
		});
		
		for(int i=0; i<THREAD_NUM; i++){
			new Thread(new WorkThread(cb)).start();
		}
	}
	
}

class WorkThread implements Runnable{
	int i = 0;
	CyclicBarrier cb;
	
	public WorkThread(CyclicBarrier inputCb) {
		this.cb = inputCb;
	}
	@Override
	public void run() {
		try {
			System.out.println(Thread.currentThread().getId() + " thread is waiting");
			cb.await();
			System.out.println(Thread.currentThread().getId() + " thread is working");
		} catch (InterruptedException | BrokenBarrierException e) {
			e.printStackTrace();
		}
		
	}
	
}

/*
10 thread is waiting
11 thread is waiting
12 thread is waiting
13 thread is waiting
14 thread is waiting
when do I execute?
11 thread is working
13 thread is working
12 thread is working
10 thread is working
14 thread is working
 */


豆瓣酱1991
关注
专栏目录
Java——线程之实现多线程
smile4548656的博客
04-24 647
Java——实现多线程一、进程二、线程三、多线程的实现方式四、设置和获取线程名称五、线程调度六、Thread类中设置和获取线程优先级的方法七、线程控制八、线程的生命周期 一、进程 进程是正在运行的程序 进程是系统进行资源分配和调用的独立单位 每一个进程都有自己的内存空间和系统资源 二、线程 线程是进程中的单个顺序控制流，是一条执行路径 单线程：一个进程如果只有一条执行路径，则称为单线程程序 多线程：一个进程如果有多条执行路径，则称为多线程程序 三、多线程的实现方式 1、方式1：继承Thread类
JAVA中实现多线程
Zhanhan15977的博客
05-15 5555
一，JAVA中实现多线程（一） 1，在Java中负责线程的这个功能的是Java.lang.Thread 这个类 2，可以通过创建 Thread 的实例来创建新的线程。 3，每个线程都是通过某个特定Thread对象所对应的方法run( )来完成其操作的，方法run( )称为线程体。 4，通过调用Thead类的start()方法来启动一个线程。 二，创建线程的方式一继承Thread类 操作步骤： 【1】继承Thread类 【2】重写run方法 【3】创建对象，调用start()方法启动线程 三
JAVA多线程实现和应用总结
weixin_34405354的博客
01-09 460
最近在做代码优化时学习和研究了下JAVA多线程的使用，看了菜鸟们的见解后做了下总结。1.JAVA多线程实现方式JAVA多线程实现方式主要有三种：继承Thread类、实现Runnable接口、使用ExecutorService、Callable、Future实现有返回结果的多线程。其中前两种方式线程执行完后都没有返回值，只有最后一种是带返回值的。 2.继承Thread类实现多线程继承T...
Java多线程实现
dosthing的博客
10-13 3152
前言 多线程的应用使程序拥有并发运行的能力，进而实现程序的多任务作业。在java中主要提供两种方式现实多线程，它们需要继承java.lang.Thread类或实现java.lang.Runnable接口。 继承Thread类 程序员启动一个新线程需要建立Thread实例，Thread类中常用的两个构造方法如下： Public Thread(): 创建一个新的线程对象 Public Thr...
java多线程实现
吻得太逼真的博客
10-10 132
1.线程的生命周期 2.创建线程的方式，继承Thread和实现Runnable接口 package it.com.cn.thread; public class ThreadCreate { public static void main(String[] args) { MyThread myThread = new MyThread();...
Java多线程的实现
dawn_after_dark的博客
07-01 518
前言虽然已经有了很多关于多线程的实现的博客和文章，但是我觉得还是写出自己的理解比较好，记录一下当时的理解，以后若是忘了可是快速按照自己当时的理解重新掌握。 Java多线程的实现，我目前只掌握了2种方式：继承Thread类和实现Runnable接口，这两种方式的run方法都是无返回值的。继承Thread类其实Thread本身也是实现了Runnable接口的一种实例，我们这里只需继承Thread,就可
Java实现多线程，使用Java实现多线程
07-06
Java实现多线程，使用Java实现多线程
Java实现多线程轮流打印1-100的数字操作
09-07
本文将详细讲解如何使用Java实现多线程轮流打印1-100的数字，以及在此过程中遇到的并发问题及其解决方案。 首先，我们要理解基本的Java线程创建和运行方式。在示例代码中，通过`Thread`类和`Runnable`接口创建了多...
使用java的HttpClient实现多线程并发
09-01
为了实现多线程并发，我们需要创建一个`Runnable`任务，该任务用于执行HTTP GET请求： ```java public class GetTask implements Runnable { private final String url; public GetTask(String url) { this.url ...
java多线程模拟队列实现排队叫号
04-15
下面我们将详细探讨如何使用Java实现这样的系统。 首先，我们需要理解队列数据结构。队列是一种先进先出（FIFO，First In First Out）的数据结构，类似于现实生活中的排队。在Java中，我们可以使用`java.util.Queue...
java实现多线程卖票功能
08-25
在本文中，我们将通过一个简单的示例程序，来详细介绍如何使用Java实现多线程卖票功能。 首先，需要了解Java中多线程编程的基础知识。在Java中，有两种方式可以实现多线程：继承Thread类和实现Runnable接口。在本文...
java实现多线程
u012289399的博客
10-08 230
java实现多线程有两种方法 继承Thread类 实现Runnable接口 这两种方法的共同点： 不论用哪种方法，都必须用Thread（如果是Thead子类就用它本身）产生线程，然后再调用start()方法。 两种方法的不同点： 继承Thread类有一个缺点就是单继承，而实现Runnable接口则弥补了它的缺点，可以实现多继承。 继承Thread类必须如果产生Runnable实例对象，就必须产生多个Runnable实例对象，然后再用Thread产生多个线程；而实现Runnable接口，只
Java之多线程的实现
HL_HLHL的博客
11-17 241
进程与线程的概念 进程：操作系统中一个程序的执行周期 线程：一个进程同时执行多个任务。通常来讲，每个任务就称为一个线程。 线程与进程比较： 1.线程更加的“轻量级”，创建、撤销一个线程比启动、撤销一个进程开销要小的多。一个进程中的所有线程共享此进程的所有资源。 2.没有进程就没有线程，进程一旦终止，其内的线程也将不复存在 3.进程是操作系统资源调度的基本单位，进程可以独享资源。线程需要依托进程提供...
Java——多线程实现（一）
qq_41201881的博客
07-19 246
介绍 继承Thread类创建线程 Thread类本质上是实现了Runnable接口的一个实例，代表一个线程的实例。启动线程的唯一方法就是通过Thread类的start()实例方法。start()方法是一个native方法，它将启动一个新线程，并执行run()方法。这种方式实现多线程很简单，通过自己的类直接extend Thread，并复写run()方法，就可以启动新线程并执行自己定义的run(...
java多线程：线程的实现
LifeGoesOn
10-08 605
一、用户线程 && 内核线程 线程：一般分为 用户线程（ULT） 和 内核线程（KLT）。 用户线程： 用户程序实现,不依赖操作系统核心,应用提供创建、同步、调度和管理线程的函数来控制用户线程。不需要用户态/内核态切换,速度快。内核对ULT无感知,线程阻塞则进程(包括它的所有线程)阻塞。 也就是说用户程序管理。 内核线程(KLT)： 系统内核管理线程(KLT),内核保存线程的状态和上下文信息,线程阻塞不会引起进程阻塞。在多处理器系统上,多线程在多处理器上并行运行。线程的创建、调度和管理由内核
JAVA多线程实现的方式
little__stars的博客
09-05 223
JAVA多线程实现方式主要有四种：继承Thread类，实现Runnable接口、实现Callable接口通过FutureTask包装器来创建Thread 线程、使用ExecutorService、Callable、Future实现有返回结果的线程。 1、继承Thread类创建线程 Thread类本质上是实现Runnable接口的一个实例，代表一个线程的实例，启动线程的唯一方法就是通过Threa...
java.lang.UnsupportedClassVersionError：JDK版本不一致出错
卡卡罗特
08-02 7003
尝试运行spring boot程序时出现如下错误： java.lang.UnsupportedClassVersionError: org/apache/lucene/store/Directory : Unsupported major.minor version 51.0 at java.lang.ClassLoader.defineClass1(Native Method) at ja
使用Java实现多线程HTTP下载工具
在Java中，我们可以通过`java.lang.Thread`类或者`ExecutorService`接口来实现多线程。 11.2 建立下载工具的界面是整个工具的核心部分。主界面是用户与下载工具交互的主要场所，它通常包含以下几个组件： - 导航树...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值