Java学习----线程-CSDN博客

本文链接：https://blog.csdn.net/hanxuya/article/details/126353987

本文详细介绍了Java中的多线程概念，包括并行与并发的区别、线程与进程的关系、线程的创建与管理。讨论了主线程、线程同步以及线程池的使用，同时讲解了进程中的僵尸进程和孤儿进程问题。此外，还通过实例展示了通过继承Thread、实现Runnable接口以及使用Callable和Future接口创建线程的方法。最后，提到了线程池的优势和ExecutorService的使用。

摘要由CSDN通过智能技术生成

今日学习内容总结如下：

并行与并发并行：

多个cpu实例或者多台机器同时执行一段处理逻辑，是真正的同时。

并发：通过cpu调度算法，让用户看上去同时执行，实际上从cpu操作层面不是真正的同时。并发往往在场景中有公用的资源，那么针对这个公用的资源往往产生瓶颈，我们会用TPS（每秒钟处理的事务数）或者QPS（每秒钟处理的请求数）来反应这个系统的处理能力。

主线程

线程是进程中的一个实体，用来描述进程的执行，它负责执行包括在进程的地
址空间中的代码。
创建一个进程时，它的第一个线程称为主线程，它由系统自动生成
它是产生其他子线程的线程
通常它是最后完成执行，因为它执行各种关闭动作。注意这里不绝对

进程中线程之间的关系

线程不像进程，一个进程中的线程之间是没有父子之分的，都是平级关系。
即线程都是一样的, 退出了一个不会影响另外一个。但是所谓的主线程main可以在执行完处理逻辑后调用System.exit()。exit会让整个进程over终止，那所有线程自然都会退出。

进程和线程的关系

一个线程只能属于一个进程，而一个进程可以有多个线程，但至少有一个线程（主线程）。
资源分配给进程，同一进程的所有线程共享该进程的所有资源。
线程在执行过程中需要协作同步。
CPU分给线程，即真正在处理机上运行的是线程。
线程是指进程内的一个执行单元，也是进程内的可调度实体，两者都是动态的概念。

线程和进程的区别[面试]

调度：线程是CPU调度和分配的基本单位，进程是系统资源分配和调度的基本单位。
并发性：不仅进程之间可以并发执行，同一个进程的多个线程之间也可以并发执行，一个进程至少有一个线程（单进程单线程），一个线程必须隶属于某个进程。
拥有资源：进程是拥有资源的一个独立单位，线程不拥有系统资源，但可以访问隶属于进程的资源。

进程和线程最大的区别在于：进程是由操作系统来控制的，而线程是由进程来控制的。
线程本身的数据通常只有寄存器数据，以及一个程序执行时使用的堆栈，所以线程的切换比进程切换的负担要小
多个进程的内部数据和状态都是完全独立的，而多线程是共享一块内存空间和一组系统资源，有可能互相影响

进程

僵尸进程和孤儿进程

僵尸进程是当子进程比父进程先结束，而父进程又没有回收子进程，释放子进程占用的资源，此时子进程将成为一个僵尸进程。如果父进程先退出，子进程被init接管，子进程退出后init会回收其占用的相关资源 ---是对系统资源的浪费，必须解决

孤儿进程是一个父进程退出，而它的一个或多个子进程还在运行，那么那些子进程将成为孤儿进程。孤儿进程将被init进程(进程号为1)所收养，并由init进程对它们完成状态收集工作。---没有什么危害

import java.util.concurrent.Semaphore;

/*
 * 多次运行会发现执行顺序不一定相同，这就是多线程运行过程的不可重现性
 * （执行的顺序不能保证），运行结果应该是一致的
 * 
 * Semaphore
 */
public class Test1 {
	public static void main(String[] args) {
		//创建线程对象，然后调用start方法则可以启动一个线程，运行的代码就是run方法中的代码
		Thread t1 = new Thread() {
			public void run() {
				for(int i=0;i<10;i++) {
					System.out.println("左手一个慢动作");
					try {
						Thread.sleep(200);  //使当前线程休眠200ms
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
				}
			}
		};
		Thread t2 = new MyThread();
		t1.start();
		t2.start();
	}
}

class MyThread extends Thread {
	@Override
	public void run() {
		for(int i=0;i<10;i++) {
			System.out.println("右手慢动作重播");
			try {
				Thread.sleep(200);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}
}

创建线程的4种方法：

继承Thread
实现Runnable接口
使用Callable和Future接口创建线程
线程池

常见问题总结

一般创建线程对象时不建议使用extends Thread方法？单根继承

一般没有返回结果时建议使用Runnable接口，如果有返回值一般建议使用Callable接口
如果使用线程比较频繁建议使用线程池

/*
 * 继承Thread
 * 
 * 调用线程对象的start方法启动线程，不能直接调用run方法，否则是单线程
 * 
 * Java采用的是单根继承体系，所以一旦继承于Thread类，则不能继承其它类
 */
public class Test1 {
public static void main(String[] args) {
	System.out.println(Thread.currentThread()); //获取当前线程对象
	//方法1.2
	Thread t2=new Thread() {
		@Override
		public void run() {
			for(int i=0;i<50;i++) {
				System.out.println("右手慢动作重播"+Thread.currentThread());
				try {
					Thread.sleep(150);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
		}
	};
//	t2.run();
	Thread t1=new MyThread3();
	t1.start();
	t2.start();
}
}

//方法1.1
class MyThread3 extends Thread{
	@Override
	public void run() {
		for(int i=0;i<50;i++) {
			System.out.println("左手一个慢动作"+Thread.currentThread());
			try {
				Thread.sleep(200);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}
}

启动线程的唯一方法就是通过Thread类的start()实例方法，不能直接调用run()方法。从语法上来说没有错误，但是不是多线程

start()方法是一个native方法，它将启动一个新线程，并执行run()方法。

这种方式实现多线程很简单，通过自己的类直接extend Thread，并复写run()方法，就可以启动新线程并执行自己定义的run()方法

public class Thread implements Runnable

重要属性

private Runnable target;

如果不覆盖定义Thread类种的run方法，则默认调用接口方法的实现，覆盖定义时不能修改方法签名

public void run(){
    if(target!=null) target.run();
}

构造器

public Thread(Runnable target) {
    this(null, target, "Thread-" + nextThreadNum(), 0);
}
public Thread(ThreadGroup group线程组, Runnable target) {
    this(group, target, "Thread-" + nextThreadNum(), 0);
}

start方法

public synchronized void start() {
        if (threadStatus != 0)  //当前线程状态检查
            throw new IllegalThreadStateException();
        //表示只有线程对象创建后才能调用start，如果已经调用了start再次调用会报异常
            
        group.add(this);  //将当前线程对象添加到一个线程组中进行管理
        boolean started = false;  //标志值用于判断当前线程是否已经启动
        try {
            start0();
            started = true;
        } finally {
            try {
                if (!started) {
                    group.threadStartFailed(this);
                }
            } catch (Throwable ignore) {
            }
        }
    }

private native void start0();//通过对等类实现启动线程的细节，内部就是自动调用run()方法

定义线程类

class LeftThread extends Thread{
  //定义左手线程类，只需要覆盖（重写）定义其中的run()方法，这里实际就是线程的执行线索，执行的程序
    public void run(){
        for(int i=0;i<50;i++)
        	System.out.println("左手一个慢动作....")
    }
}

调用方法

Thread t1=new LeftThread();
t1.start();//启动线程必须使用start方法，而不能是调用run方法
//t1.run()；不允许直接调用run方法，因为这种调用方式不是多线程，而是单线程

最简单的方式是查看线程个数

// Thread.currentThread()用于获取当前正在运行这个代码的线程对象
System.out.println(Thread.currentThread());
Thread t1 = new LeftThread();
// t1.run();在当前主线程中执行t1对象中的run方法
// t1.start();可以在LeftThread中获取到另外一个线程对象

输出线程对象

public String toString() {
        ThreadGroup group = getThreadGroup();
        if (group != null) {
            return "Thread[" + getName()线程名称 + "," + getPriority()优先级 + "," +
                           group.getName() 所属线程组的名称+ "]";
        } else {
            return "Thread[" + getName() + "," + getPriority() + "," +
                            "" + "]";
        }
    }

public class LeftThread extends Thread {
	@Override
	public void run() {// 这里包含的就是执行线索
		System.out.println(Thread.currentThread());
	}
}

最大的限制实际上就是Java的单根继承体系，这种方式基本不用

实现Runnable接口

/*
 * 
 * 源代码
 * @FunctionalInterface   注解声明是函数式接口
 * public interface Runnable {
 *     public abstract void run();
 * }
 * 
 * 问题：定义run()方法没有返回值
 */
public class Test2 {
	public static void main(String[] args) {
		Thread t1 = new Thread(new MyRunnable());
		t1.start();
		// 方法2.2
		new Thread(new Runnable() {
			public void run() {
				for (int i = 0; i < 10; i++) {
					System.out.println("中间手...."+Thread.currentThread());
					try {
						Thread.sleep(100);
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
				}
			}
		}).start();
		// 方法2.3
		new Thread(() -> {
			for (int i = 0; i < 10; i++) {
				System.out.println("右手...."+Thread.currentThread());
				try {
					Thread.sleep(100);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
		}).start();
	}
}

//方法2.1
class MyRunnable implements Runnable {
	public void run() {
		for (int i = 0; i < 10; i++) {
			System.out.println("左手...."+Thread.currentThread());
			try {
				Thread.sleep(100);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}

}

使用Callable和Future接口创建线程
具体是创建Callable接口的实现类，并实现call()方法。并使用FutureTask类来包装
Callable实现类的对象，且以此FutureTask对象作为Thread对象的target来创建线程

java.util.concurrent.Callable 有时java.util.concurrent包可以称为juc包

@FunctionalInterface 注解用于声明当前接口是一个函数式接口
public interface Callable<V> { 这里<>中用于声明返回值的类型
V call() throws Exception; 真正执行的方法，有返回值，允许抛出异常
}

线程的构造器为

public Thread(Runnable target) {
this(null, target, "Thread-" + nextThreadNum(), 0);
}

Future接口
    public interface Future<V> {
    boolean cancel(boolean mayInterruptIfRunning); 可以取消正在运行的线程
    boolean isCancelled(); 判断是否取消
    boolean isDone(); 判断线程是否在运行中
    V get() throws InterruptedException, ExecutionException; 获取线程执行的结果
    V get(long timeout, TimeUnit unit)throws InterruptedException, ExecutionException, TimeoutException;

Java针对Future接口提供的具体实现类FutureTask

源代码:

public class FutureTask<V> implements RunnableFuture<V>
	
	public interface RunnableFuture<V> extends Runnable, Future<V>

构造器

public FutureTask(Callable<V> callable) {
        if (callable == null)
            throw new NullPointerException();
        this.callable = callable;
        this.state = NEW;       // ensure visibility of callable
    }

public void run() {
            Callable<V> c = callable;
            ...
                    result = c.call();
    }

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

public class Test3 {
	public static void main(String[] args) throws Exception {
		// 为了获取返回值，所以需要使用FutureTask中提供的get方法
		FutureTask<Integer>[] arr = new FutureTask[10];
		for (int i = 1; i <= 10; i++) {
			int begin = (i - 1) * 100 + 1;
			int end = i * 100;
			// 定义Callable的实现
			Callable<Integer> c = new Callable<Integer>() {
				public Integer call() throws Exception {
					int res = 0;
					for (int k = begin; k <= end; k++)
						res += k;
					return res;
				}
			};
			// 构建FutureTask对象，其中包含Callable对象
			FutureTask<Integer> ft = new FutureTask<>(c);
			// 不是必须的，只是证明FutureTask实现了Runnable接口
			Runnable r = ft;
			arr[i - 1] = ft;
			// 启动线程，构建Thread对象时，要求参数类型为Runnable接口类型
			// 线程执行时会自动调用run方法，而FutureTask中提供的run方法会调用Callable对象的//call方法
			new Thread(r).start();
		}
		int res = 0;
		for (FutureTask<Integer> tmp : arr)
			res += tmp.get(); // main线程执行到这里时，会自动阻塞等待子线程tmp执行结束，执行结//束后获取call方法的返回值
		System.out.println(res);
	}
}

注意:FutureTask实现了Future和Runnable接口，所以new Thread(futureTask),当执行thread.start()方法时会自动调用Callable接口实现中的call方法。当调用futureTask.get()方法时可以获取对应的线程对象的执行结果，如果线程并没有返回时，当前线程阻塞等待

使用线程池创建线程

享元模式Flyweight Pattern主要用于减少创建对象的数量，以减少内存占用和提高性能。这种类型的设计模式属于结构型模式，它提供了减少对象数量从而改善应用所需的对象结构的方式

优点：大大减少对象的创建，降低系统内存的使用，以提高程序的执行效率。

缺点：提高了系统的复杂度，需要分离出外部状态和内部状态，而且外部状态具有固有化的性质，不应该随着内部状态的变化而变化，否则会造成系统的混乱。

public class Test4 {
public static void main(String[] args)throws Exception {
	for(int i=0;i<100;i++) {
		IShape tmp=ObjectManager.getInstance();
		System.out.println(tmp);
		ObjectManager.releaseInstance(tmp);
	}
}
}

interface IShape {
	public void draw();
}

class Circle implements IShape {
	public void draw() {
		System.out.println("绘制一个圆形");
	}
}

//共享所有的IShape类型的对象，当需要使用IShape对象时，从对象池中获取一个即可
//，不是临时创建；当不需要使用对象时，不是直接释放对象，而是归还对象池
class ObjectManager {
	private static IShape[] arr = new IShape[20];
	static { // 类加载完毕，则在对象池中已经准备好了20个对象
		for (int i = 0; i < arr.length; i++)
			arr[i] = new Circle();
	}

	// 当需要使用对象时，从对象池中获取一个对象即可
	public static IShape getInstance() {
		IShape res = null;
		for (int i = arr.length - 1; i >= 0; i--) {
			res = arr[i];
			if (res != null) {
				arr[i] = null;
				break;
			}
		}
		return res;
	}

	// 当不使用对象时，需要归还到对象池中，以供下次需要时再次使用
	public static void releaseInstance(IShape obj) {
		for (int i = 0; i < arr.length; i++) {
			IShape tmp = arr[i];
			if (tmp == null) {
				arr[i] = obj;
				break;
			}
		}
	}
}

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.FutureTask;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

/*
 * 使用ExecutorService、Callable、Future实现有返回结果的线程，线程池
 * 的具体实现实际上是依赖于ThreadPoolExecutor
 */
public class Test40 {
	public static void main(String[] args) {
		// 固定大小的线程池，容积为3
//		ExecutorService es = Executors.newFixedThreadPool(3);
		//缓存线程池
		ExecutorService es=Executors.newCachedThreadPool();
		FutureTask<Integer>[] fs = new FutureTask[10];
		for (int i = 1; i <= 10; i++) {
			int begin = (i - 1) * 100 + 1;
			int end = i * 100;
			fs[i-1] = new FutureTask<>(new Callable<Integer>() {
				public Integer call() throws Exception {
					System.out.println(Thread.currentThread());
					int res = 0;
					for (int k = begin; k <= end; k++)
						res += k;
					return res;
				}
			});
			es.submit(fs[i-1]);
		}
		int res = 0;
		for (Future<Integer> f : fs) {
			try {
				res += f.get(1, TimeUnit.SECONDS);
			} catch (InterruptedException | ExecutionException | TimeoutException e) {
				e.printStackTrace();
			}
		}
		System.out.println(res);
	}
}

创建线程要花费昂贵的资源和时间，如果任务来了才创建线程那么响应时间会变长，而且一个进程能创建的线程数有限。为了避免这些问题，在程序启动的时候就创建若干线程来响应处理，它们被称为线程池，里面的线程叫工作线程。

从JDK1.5开始，Java API提供了Executor框架可以创建不同的线程池。比如单线程池，每次处理一个任务；数目固定的线程池或者是缓存线程池（一个适合很多生存期短的任务的程序的可扩展线程池）

new Thread的弊端

每次new Thread新建对象性能差。
线程缺乏统一管理，可能无限制新建线程，相互之间竞争及可能占用过多系统资源导致死机或oom。
缺乏更多功能，如定时执行、定期执行、线程中断。

针对OOM的面试

OutOfMemoryError即OOM的可能原因?

数据库的cursor没有及时关闭
未关闭InputStream OutputStream
Bitmap 使用后未调用recycle()
static等关键字
非静态内部类持有外部类的引用context泄露
流量/数据量峰值：应用程序在设计之初均有用户量和数据量的限制，某一时刻，当用户数量或数据量突然达到一个峰值，并且这个峰值已经超过了设计之初预期的阈值，那么以前正常的功能将会停止，并触发java.lang.OutOfMemoryError: Java heap space异常。
内存泄漏：特定的编程错误会导致你的应用程序不停的消耗更多的内存，每次使用有内存泄漏风险的功能就会留下一些不能被回收的对象到堆空间中，随着时间的推移，泄漏的对象会消耗所有的堆空间，最终触发java.lang.OutOfMemoryError: Java heap space错误。

线程池的好处

重用存在的线程，减少对象创建、消亡的开销，性能佳
可有效控制最大并发线程数，提高系统资源的使用率，同时避免过多资源竞争，避免堵塞
提供定时执行、定期执行、单线程、并发数控制等功能。

线程池的工作原理

1、线程池判断核心线程池里的线程是否都在执行任务。如果不是，则创建一个新的工作线程来执行任务。如果核心线程池里的线程都在执行任务，则执行第二步。

2、线程池判断工作队列是否已经满。如果工作队列没有满，则将新提交的任务存储在这个工作队列里进行等待。如果工作队列满了，则执行第三步

3、线程池判断线程池的线程是否都处于工作状态。如果没有，则创建一个新的工作线程来执行任务。如果已经满了，则交给饱和策略来处理这个任务

public ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime,TimeUnit unit, BlockingQueue<Runnable> workQueue)

public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue,
                              ThreadFactory threadFactory,
                              RejectedExecutionHandler handler)

corePoolSize线程池的核心大小
maximumPoolSize线程池中允许的最大线程数
workQueue阻塞任务队列
threadFactory线程工厂
RejectedExecutionHandler饱和处理策略

import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

public class Test41 {
	public static void main(String[] args) throws Exception {
		// 创建线程池
		ExecutorService es = Executors.newCachedThreadPool();
		// 提交任务到线程池中
		Future f = es.submit(() -> {
			int sum = 0;
			for (int i = 0; i <= 100; i++)
				sum += i;
			return sum;
		});
		Object res = f.get();
		System.out.println(res);
	}
}

守护线程

正常情况下，非守护线程的执行时间和主线程无关，即使主线程已经结束，也不会影响子线程的运行。

守护线程是为其它线程提供服务的线程

守护进程的特点是当程序中主线程结束时，守护线程会自动中止

如何将一个子线程设置为守护线程

在一个线程调用start启动之前，调用方法thread.setDaemon(true);就可以将thread线程设置为守护线程.

守护线程一般应该是一个独立的线程，它的run()方法是一个无限循环

守护线程与其它线程的区别是，如果守护线程是唯一运行着的线程，程序会自动退出

线程组

Thread类的构造器

public Thread(String name) {
        this(null, null, name, 0);
    }
    
     public Thread(Runnable target, String name) {
        this(null, target, name, 0);
    }

Thread线程类中toString方法的定义

public String toString() {
	ThreadGroup group = getThreadGroup();//获取当前线程对象所属的线程组
    if (group != null) {
    	return "Thread[" + getName() + "," + getPriority() + "," + group.getName() + "]";
	} else {
    	return "Thread[" + getName() + "," + getPriority() + "," + "" + "]";
    }
}

所有线程都隶属于一个线程组。那可以是一个默认线程组【main】，亦可是一个创建线程时明确指定的组

说明
在创建之初，线程被限制到一个组里，而且不能改变到一个不同的组
若创建多个线程而不指定一个组，它们就会与创建它的线程属于同一个组

创建线程指定对应的线程组

public Thread(ThreadGroup group, Runnable target)
public Thread(ThreadGroup group, String name)
public Thread(ThreadGroup group, Runnable target, String name)

ThreadGroup myThreadGroup = new ThreadGroup("My Group");//创建线程组
Thread myThread = new Thread(myThreadGroup,"a thread");  //定义线程时指定对应的线程组
theGroup = myThread.getThreadGroup();//获取线程对象所属的线程组

public class Test3 {
	public static void main(String[] args) {
		//创建线程组，指定名称yan1
		ThreadGroup group = new ThreadGroup("yan1");
		//创建线程，并指定线程所属的线程组
		Thread t1 = new Thread(group, () -> {
			for (int i = 0; i < 100; i++) {
				; //Thread[Thread-0,5,yan1]
				ThreadGroup gg=new ThreadGroup("yan1-"+i);
				new Thread(gg,()->{
					for(int k=0;k<100;k++);
				}).start();
			}
		});		
		t1.start();
		
		System.out.println(Thread.currentThread());//输出当前线程  main
		
		
		// 线程组的用途
		ThreadGroup tg = Thread.currentThread().getThreadGroup();
		System.out.println("ddd:"+tg);//java.lang.ThreadGroup[name=main,maxpri=10]
		int cc = tg.activeCount();// 获取所有活跃线程线程数
		System.out.println("ddd:"+cc);
		
		Thread[] list = new Thread[cc];
		tg.enumerate(list);// 获取所有获取线程，并存放在Thread[]中
		
		for (Thread temp : list)
			System.out.println("eee:"+temp);
		/*
		 * Thread[main,5,main]
		 * Thread[Thread-0,5,yan1]
		 */
		
		tg.list();// 以树装结构显示当前的所有线程组
		/*
		 * java.lang.ThreadGroup[name=main,maxpri=10]
    			Thread[main,5,main]
    			java.lang.ThreadGroup[name=yan1,maxpri=10]
		 */
		
		System.out.println("========================");
		cc=group.activeCount();
		System.out.println("yan1:"+cc);
		group.list();
	}
}

主要通途：可以通过线程组，对线程组中一组线程进行统一管理，而不是一个一个的管理。注意显示线程时，如果线程显示为null表示线程已经消亡（执行结束）。在具体开发中很少使用