1.1 创建线程
1.1.1 创建线程的四种方式
【1】继承Thread类
【2】实现Runnable接口
【3】实现Callable,获取返回值
【4】实现FutureTask类
Thread类是一个Runnable接口的实现类,Thread类中通过调用私有的init来实现初始化。
g
:线程组
target
:实现Runnable接口的线程处理类
name
:线程名称,如果没有指定则默认Thread-随机数
stackSize
:线程初始栈大小
1.1.2 Thread类与Runnable接口的比较
1:由于Java“单继承,多实现”的特性,Runnable接口使用起来比Thread更灵活。
2:Runnable接口出现更符合面向对象,将线程单独进行对象的封装。
3:Runnable接口出现,降低了线程对象和线程任务的耦合性。
4:如果使用线程时不需要使用Thread类的诸多方法,显然使用Runnable接口更为轻量。Thread是扩展了Runnable接口的对象。
1.1.3 Callable、Future与FutureTask
使用Runnable和Thread来创建一个新的线程。但是它们有一个弊端,就是run方法是没有返回值的。而有时候我们希望开启一个线程去执行一个任务,并且这个任务执行完成后有一个返回值。
@FunctionalInterface
public interface Callable<V> {
V call() throws Exception;
}
Callable一般是配合线程池工具ExecutorService来使用的。ExecutorService可以使用submit方法来让一个Callable接口执行。它会返回一个Future,我们通过
Future.get()就可以获取线程执行的返回结果了。
1.2 线程组和线程优先级
Java中用ThreadGroup来表示线程组,我们可以使用线程组对线程进行批量控制。
ThreadGroup和Thread的关系就如同他们的字面意思一样简单粗暴,每个Thread必然存在于一个ThreadGroup中,Thread不能独立于ThreadGroup存在。执行main()方法线程的名字是main,如果在new Thread时没有显式指定,那么默认将父线程(当前执行new Thread的线程)线程组设置为自己的线程组。
ThreadGroup管理着它下面的Thread,ThreadGroup是一个标准的向下引用的树状结构,这样设计的原因是防止”上级”线程被”下级”线程引用而无法有效地被GC回收。
Java中线程优先级可以指定,范围是1~10。但是并不是所有的操作系统都支持10级优先级的划分(比如有些操作系统只支持3级划分:低,中,高),Java只是给操作系统一个优先级的参考值,线程最终在操作系统的优先级是多少还是由操作系统决定。
Java默认的线程优先级为5,线程的执行顺序由调度程序来决定,线程的优先级会在线程被调用之前设定。
通常情况下,高优先级的线程将会比低优先级的线程有更高的几率得到执行。我们使用方法Thread类的setPriority()实例方法来设定线程的优先级。
Java中的优先级来说不是特别的可靠,Java程序中对线程所设置的优先级只是给操作系统一个建议,操作系统不一定会采纳。而真正的调用顺序,是由操作系统的线程调度算法决定的。
Java提供一个线程调度器来监视和控制处于RUNNABLE状态的线程。线程的调度策略采用抢占式,优先级高的线程比优先级低的线程会有更大的几率优先执行。在优先级相同的情况下,按照“先到先得”的原则。每个Java程序都有一个默认的主线程,就是通过JVM启动的第一个线程main线程。
还有一种线程称为守护线程(Daemon),守护线程默认的优先级比较低。
如果某线程是守护线程,那如果所有的非守护线程结束,这个守护线程也会自动结束。
应用场景是:当所有非守护线程结束时,结束其余的子线程(守护线程)自动关闭,就免去了还要继续关闭子线程的麻烦。
一个线程默认是非守护线程,可以通过Thread类的setDaemon(boolean on)来设置。
【一个线程必然存在于一个线程组中,那么当线程和线程组的优先级不一致的时候将会怎样呢?】
public static void main(String[] args) {
ThreadGroup threadGroup = new ThreadGroup("t1");
threadGroup.setMaxPriority(6);
Thread thread = new Thread(threadGroup,"thread");
thread.setPriority(9);
System.out.println("我是线程组的优先级"+threadGroup.getMaxPriority());
System.out.println("我是线程的优先级"+thread.getPriority());
}
所以,如果某个线程优先级大于线程所在线程组的最大优先级,那么该线程的优先级将会失效,取而代之的是线程组的最大优先级。
1.3 Java线程的状态及主要转化方法
Enum Thread.State
【1】反复调用同一个线程的start()方法是否可行?
【2】假如一个线程执行完毕(此时处于TERMINATED状态),再次调用这个线程的start()方法是否可行?
查看Thread类中start()方法源码,代码如下
public synchronized void start() {
//threadStatus表示处于NEW状态的线程
if (threadStatus != 0)
throw new IllegalThreadStateException();
//通知当前线程的线程组这个线程将要启动,并添加当前线程到线程组中
//当前线程组未启动线程数减少
group.add(this);
boolean started = false;
try {
start0();
started = true;
} finally {
try {
//处理启动失败的线程
if (!started) {
group.threadStartFailed(this);
}
} catch (Throwable ignore) {
}
}
}
//本地方法执行线程的实际启动流程
private native void start0();
在start()内部,这里有一个threadStatus的变量。如果它不等于0,调用start()是会直接抛出异常的。
我是在start()方法内部的最开始打的断点,叙述下在我这里打断点看到的结果:
测试代码如下
@Test
public void testThreadState(){
Thread thread = new Thread(()->{
System.out.println("Thread Run...");
});
thread.start();
thread.start();
}
第一个 thread.start();执行情况如下
第二个 thread.start();执行情况如下
两个问题的答案都是不可行,在调用一次start()之后,threadStatus的值会改变(threadStatus !=0),此时再次调用start()方法会抛出IllegalThreadStateException异常。
比如,threadStatus为2代表当前线程状态为TERMINATED。
1.4 Java线程间的通信
线程同步是线程之间按照一定的顺序执行。
1.4.1 等待/通知机制
Java多线程的等待/通知机制是基于Object类的wait()方法和notify(), notifyAll()方法来实现的。
notify()方法会随机叫醒一个正在等待的线程,而notifyAll()会叫醒所有正在等待的线程。
1.4.2 信号量
JDK提供了一个类似于“信号量”功能的类Semaphore。但本文不是要介绍这个类,而是介绍一种基于volatile关键字的自己实现的信号量通信。
volitile关键字能够保证内存的可见性,如果用volitile关键字声明了一个变量,在一个线程里面改变了这个变量的值,那其它线程是立马可见更改后的值的。
【需求】让线程1输出0,然后线程2输出1,再然后线程A输出2…以此类推。我应该怎样实现呢?
private static Object lock=new Object();
private static volatile int sign=0;
static class MyThread1 implements Runnable{
@SneakyThrows
@Override
public void run() {
while (sign<5){
if (sign%2==0){
System.out.println("线程1--->"+sign);
synchronized (lock){
sign++;
}
}
}
}
}
static class MyThread2 implements Runnable{
@Override
public void run() {
while (sign<5){
if (sign%2!=0){
System.out.println("线程2--->"+sign);
synchronized (lock){
sign++;
}
}
}
}
}
public static void main(String[] args) throws InterruptedException {
Thread threadA = new Thread(new MyThread1());
Thread threadB = new Thread(new MyThread2());
threadA.start();
threadB.start();
Thread.sleep(4000);
}
注意:
上面使用了一个volatile变量signal来实现了“信号量”的模型。但是volatile仅仅只线程可见的,signal++并不是一个原子操作,所以我们需要使用synchronized给它“上锁”
1.4.3 管道
管道是基于“管道流”的通信方式。JDK提供了PipedWriter、 PipedReader、 PipedOutputStream、 PipedInputStream。其中,前面两个是基于字符的,后面两个是基于字节流的。
public class PipeExample {
static class ReaderThread implements Runnable{
private PipedReader pipedReader;
public ReaderThread(PipedReader pipedReader) {
this.pipedReader = pipedReader;
}
@Override
public void run() {
int count=0;
try
{//接收并输出流
while ((count= pipedReader.read())!=-1){
System.out.println((char)count);
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
static class WriterThread implements Runnable {
private PipedWriter writer;
public WriterThread(PipedWriter writer) {
this.writer = writer;
}
@SneakyThrows
@Override
public void run() {
try {
writer.write("qwertyui");
} catch (IOException e) {
e.printStackTrace();
}finally {
//写入管道的流必须关闭
writer.close();
}
}
}
public static void main(String[] args) throws IOException, InterruptedException {
PipedWriter writer = new PipedWriter();
PipedReader reader = new PipedReader();
// 这里注意一定要连接,才能通信
writer.connect(reader);
new Thread(new ReaderThread(reader)).start();
Thread.sleep(1000);
new Thread(new WriterThread(writer)).start();
}
}
我们通过线程的构造函数,传入了PipedWrite和PipedReader对象。可以简单分析一下这个示例代码的执行流程:
1:线程ReaderThread开始执行
2:线程ReaderThread使用管道reader.read()进入”阻塞“
3:线程WriterThread开始执行
4:线程WriterThread用writer.write(“XXXX”)往管道写入字符串
5:线程WriterThread使用writer.close()结束管道写入,并执行完毕
6:线程ReaderThread接受到管道输出的字符串并打印
7:线程ReaderThread执行完毕
管道通信的应用场景:使用管道多半与I/O流相关。当我们一个线程需要先另一个线程发送一个信息(比如字符串)或者文件等等时,就需要使用管道通信了。
总结
本篇文章就到这里了,希望能够给你带来帮助,也希望您能够多多关注编程网的更多内容!