java基础总结——线程（一）

最新推荐文章于 2021-11-23 19:12:32 发布

白垩纪往事

最新推荐文章于 2021-11-23 19:12:32 发布

阅读量132

点赞数

分类专栏： Java

Java 专栏收录该内容

6 篇文章 0 订阅

订阅专栏

近期在学习java线程，这是学习的总结。

参考资料

知识点

线程和进程的基本概念
线程的生命周期
线程的创建和启动
守护线程和用户线程
线程的调度和优先级
上下文切换
线程同步

线程和进程的基本概念

线程和进程的区别和联系

线程是程序执行的最小单元。是被系统独立调度和分派的基本单位。
线程自己不拥有系统资源，只拥有一点儿在运行中必不可少的资源。但它可与同属一个进程的其它线程共享进程所拥有的全部资源，包括代码、数据空间。
进程包括由操作系统分配的内存空间，包含一个或多个线程。一个进程一直运行，直到所有的非守护线程都结束运行后才能结束。java运行环境就是一个单一进程。
每个进程都有独立的代码和数据空间，进程间的切换会有较大的开销；相比而言，同一进程下的线程切换的开销较小。
多个线程被并发的执行可以提高程序的效率，CPU不会因为某个线程需要等待资源而进入空闲状态。

线程的生命周期

线程的创建和启动

java的线程是通过java.lang.Thread类实现的。JVM启动时会有一个由主方法（public static void main(){}）定义的线程。

每个线程都是通过某个特定Thread对象所对应的方法run()来完成操作，方法run()称为线程体。通过Thread的start()启动线程，线程启动后执行。Thread的run()方法可以被直接调用，但是，直接调用就和普通方法一样了。

另外，不能对同一线程对象两次调用start()方法。

创建新线程

Java 提供了三种创建线程的方法：

1. 通过实现 Runnable 接口；

线程类R1实现Runnable接口
Thread t1 = new Thread(new R1());
Runnable中只有run()一个方法，用于定义线程运行体。

package indi.thread.part01;
/**
 * 三种创建线程的方法：1/3
 * @author 61940
 *
 */
public class MainTest01 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Thread t = null;
		for (int i = 0; i < 100; i++) {
			MyRun run = new MyRun();
			run.start();
			MyRun.add();
		}
		System.out.println("Main id>>" + 1);
	}

}

class MyRun implements Runnable {
	private static int id = 0;
	private Thread t = null;
	private String threadName = "";
	public static int add() {
		return id++;
	}
	
	public void start(){
		threadName = "thread" + id;
		if(t == null){
			t = new Thread(this,threadName);
			System.out.println("start线程：" + threadName);
			t.start();
		}
	}
	
	@Override
	public void run() {
		System.out.println("run线程：" + threadName);
	}

}

2. 通过继承 Thread 类本身；

线程类继承Thread并重写其run()方法；
生成线程类实例并执行start()；

package indi.thread.part01;
/**
 * 三种创建线程的方法：2/3
 * @author 61940
 *
 */
public class MainTest02 {

	public static void main(String[] args) {
		MyThread1 mt = null;
		for (int i = 0; i < 100; i++) {
			mt = new MyThread1();
			mt.start();
		}
	}
}

class MyThread1 extends Thread{
	private static int id = 0;
	public MyThread1(){
		super();
	}

	public void start(){
		System.out.println("start线程：" + id);
		super.start();
	}
	
	public int add() {
		return ++id;
	}
	
	public void run(){
		System.out.println("id>>" + add());
	}
}

3. 通过 Callable 和 Future 创建线程。

Callable 接口类似于 Runnable，两者都是为那些其实例可能被另一个线程执行的类设计的。但是 Runnable 不会返回结果，并且无法抛出经过检查的异常。Callable可以做到。
线程启动时调用Callable的call()。
通过FutureTask的get()可以获取子线程的返回值。

package indi.thread.part01;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

/**
 * 三种创建线程的方法：3/3
 * @author 61940 实现Callable<T>接口，call()的返回值类型与T一致，启动线程时，调用call()方法，
 */
public class MainTest03 {
	public static void main(String[] args) {
		try {
			for (int i = 0; i < 100; i++) {
				System.out.println(Thread.currentThread().getName() + i);
				CallThread ct = new CallThread();
				FutureTask ft = ct.getFutureTask();
				new Thread(ft,("子线程" + i)).start();
				System.out.println("返回值" + ft.get());
			}
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (ExecutionException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
}

class CallThread implements Callable<String> {

	@Override
	public String call() throws Exception {
		Thread.currentThread().sleep(1000);
		System.out.println(Thread.currentThread().getName());
		return Thread.currentThread().getName();
	}

	public FutureTask<String> getFutureTask() {
		FutureTask<String> ft = new FutureTask<String>(this);
		return ft;
	}
}

守护线程和用户线程

为程序其他线程（可以理解为前台线程）提供服务，如JVM的垃圾回收线程。
守护线程的生命周期与前台线程有一定的关联，具体表现为当所有的前台线程进入死亡状态后，守护线程自动死亡。
设置守护线程：调用Thread对象的setDaemon(true)方法可以将指定的线程设置为守护线程。
判断线程是否是守护线程：调用thread对象的isDeamon()方法。
main线程默认是前台线程，前台线程创建中创建的子线程默认是前台线程，守护线程中创建的子线程默认是守护线程。
如果需要将前台线程设置为守护线程，需要在start()方法调用之前调用调用setDeamon(true)方法。
前台线程都死亡后，JVM通知守护线程死亡，但从接收指令到作出响应，需要一定的时间。

线程的调度和优先级

每一个 Java 线程都有一个优先级，这样有助于操作系统确定线程的调度顺序。
Java 线程的优先级是一个整数，其取值范围是 1 （Thread.MIN_PRIORITY） - 10 （Thread.MAX_PRIORITY）。
默认情况下，每一个线程都会分配一个优先级 NORM_PRIORITY（5）。可以用setPriority(int priority)
具有较高优先级的线程对程序更重要，并且应该在低优先级的线程之前分配处理器资源。但是，线程优先级不能保证线程执行的顺序，而且非常依赖于平台。

上下文切换

多线程环境中，当一个线程的状态由Runnable转换为非Runnable（Blocked、Waiting、Timed_Waiting）时，相应线程的上下文信息（包括cpu的寄存器和程序计数器在某一时间点的内容等）需要被保存，以便相应线程稍后再次进入Runnable状态时能够在之前的执行进度的基础上继续前进。而一个线程从非Runnable状态进入Runnable状态可能涉及恢复之前保存的上下文信息。这样的对线程的状态的保存和恢复的过程就是上下文切换。

上下文切换会带来额外的开销，这包括对线程上下文信息保存和恢复的开销，对线程进行调度的cpu时间开销以及cpu缓存失效的开销。

白垩纪往事

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
java基础总结——线程（一）

近期在学习java线程，这是学习的总结。参考资料概念http://www.runoob.com/java/java-multithreading.html上下文切换https://www.cnblogs.com/xrq730/p/5186609.htmlhttps://blog.csdn.net/u014527912/article/details/78939781ja...
复制链接

扫一扫