程序:是为了完成特定任务、用某种语言编写的一组指令集合,即指一段静态的代码,静态对象
进程:是程序的一次执行过程,或是正在运行的一个程序,是一个动态的过程:它有自身的产生、存在和消亡的过程—生命周期
比如:运行的QQ,运行中的MP3播放器
程序是静态的,进程是动态的
线程:进程可进一步细化为线程,是一个程序内部的一条执行路径
若一个进程同一时间并行执行多个线程,就是支持多线程的
线程作为调度和执行的单位,每个线程拥有独立的运行栈和程序计数器(pc),线程切换的开销小
一个进程中的多个线程共享相同的内存单元/内存地址空间–》他们从同一堆中分配对象,可以访问相同的变量和对象。这就使得线程间通信更简便、高效。但多个线程操作共享的系统资源可能就会带来安全的隐患。
单核CPU和多核CPU的理解:
单核CPU,其实是一种假的多线程,因为在一个时间单元内,只能执行一个线程的任务。
如果是多核的话,才能更好的发挥多线程的效率。(现在的服务器都是多核的)
一个Java应用程序java.exe,其实至少有三个线程:main() 主线程 ,gc()垃圾回收线程,异常处理线程。当如果发生异常,会影响主线程
并行与并发:
使用多线程的优点:
- 提高应用程序的响应。对图形化界面更有意义,可增强用户体验
- 提高计算机系统CPU的利用率
- 改善程序结构。将既长又复杂的进程分为多个线程,独立运行,利于理解和修改
何时需要多线程:
- 程序需要同时执行两个或多个任务
- 程序需要实现一些需要等待的任务时,如用户输入、文件读写操作、网络操作、搜索等
- 需要一些后台运行的程序时
多线程的创建:
多线程创建,方式一:继承Thread类
- 第一步:创建一个继承Thread类的子类。
- 第二步:重写Thread类的run()方法 —》将此线程执行的操作放在run()方法中
- 第三步:创建Thread类的子类对象
- 第四步:通过此对象调用start()方法 ----- 1.启动当前线程 2.调用当前线程的run()方法
问题二:再启动一个线程,遍历100以内的偶数,不可以还让已经start()的线程去执行,会报
IllegalThreadStateException异常。
解决方法:我们需要重新创建一个线程的对象
public class MyThread extends Thread{
/**
* 多线程创建,方式一:继承Thread类
* 第一步:创建一个继承Thread类的子类
* 第二步:重写Thread类的run()方法---》将此线程执行的操作放到run()中
* 第三步:创建Thread类的子类对象
* 第四步:通过此对象调用start()方法
*/
/**
* 例子:遍历100内的所有偶数
*/
@Override
public void run() {
for (int i = 0; i <= 100; i++) {
if(i % 2 == 0){
System.out.println(i);
}
}
}
}
class MyThreadTest {
/**
* 创建主线程,并且在主线程内创建Thread类子类对象
* @param args
*/
public static void main(String[] args) {
MyThread myThread = new MyThread();
myThread.start(); //相当于分线程
myThread.start();
//线程
for (int i = 0; i <= 100; i++) {
if(i % 2 != 0){
System.out.println(i + "***");
}
}
}
}
测试Thread中的常用方法:
-
start():启动当前线程,调用当前线程的run();
-
run():通常需要重写Thread类中的此方法,将创建的线程要执行的操作声明在此方法中;
-
currentThread():静态方法,返回执行当前代码的线程;
-
getName():获取当前线程的名字;
-
setName():设置当前线程的名字;
-
yield():释放当前CPU的执行权;
-
join():在线程a中调用线程b的join(),此时线程a就进入阻塞状态,直到线程b完全执行完以后,线程a才会结束阻塞状态;
-
stop():已过时,当执行到此方法时,强制结束当前线程。
-
sleep(Long millitime):让当前线程"睡眠"指定的millitime毫秒。在指定的millitime毫秒时间内,当前线程是阻塞状态;
-
isAlive():判断当前线程是否存活;
线程的优先级:
MAX_PRIORITY:10 最大线程优先级
MIN_PRIORITY:1 最小线程优先级
NORM_PRIORITY:5 默认线程优先级
-
如何获取和设置当前线程的优先级
- getPriority():获取线程的优先级
- setPriority(int p):设置线程的优先级
说明: 高优先级的线程要抢占低优先级线程CPU的执行权,但是只是从概率上讲,高优先级的线程高概率的情况下被执行。并不意味着只有当高优先级的线程执行完以后,低优先级的线程才执行。
比较创建线程的两种方式:
开发中:优先选择:实现Runnable接口的方式
原因:
- 实现的方式没有类的单继承性的局限性
- 实现的方式更适合来处理多个线程有共享数据的情况
联系:public class Thread Implements Runnable
相同点:两种方式都需要重写run(),将线程要执行的逻辑声明在run()中
/**
* 第二种创建线程的方式二:实现Runnable接口
* 第一步:创建一个实现Runnable接口的类
* 第二步:实现类去实现Runnable中的抽象方法:run();
* 第三步:创建实现类的对象
* 第四步:将此对象作为参数传递到Thread类的构造器中,创建Thread类的对象
* 第五步:通过Thread类的对象调用start()方法
*/
public class ThreadTest1 implements Runnable{
@Override
public void run() {
for (int i = 0; i <= 100; i++) {
if(i%2 == 0){
System.out.println(Thread.currentThread().getName()+":"+i);
}
}
}
}
class ThreadTest{
public static void main(String[] args) {
//实例化当前类的对象
ThreadTest1 threadTest1 = new ThreadTest1();
//创建
Thread thread = new Thread(threadTest1);
//设置当前线程的名称
thread.setName("分线程");
//设置当前线程的优先级
thread.setPriority(Thread.MAX_PRIORITY);
//启动线程,实现类实现Runnable接口的run()方法 -->调用了Runnable类型的target的run();
thread.start();
}
}
创建线程的方式三:实现callable接口。 —》JDK5.0新增
如何理解实现Callable接口的方式创建多线程比实现Runnable接口创建多线程方式强大?
- call()可以有返回值
- call()可以抛出异常,被外面的操作捕获,获取异常的信息
- callable是支持泛型的
//第一步:创建Callable接口的实现类
public class Call implements Callable<Integer> {
//第二步:实现call方法,并返回Integer包装类类型,和抛出异常
@Override
//通过泛型设置call()方法的返回值为Integer
public Integer call() throws Exception {
int sum = 0;
for (int i = 0; i <= 100; i++) {
if(i % 2 == 0){
System.out.println(Thread.currentThread().getName()+":"+i);
sum += i;
}
}
return sum;
}
}
class CallTest{
//主线程
public static void main(String[] args) {
//第三步:创建Callable接口实现类对象
Call call = new Call();
//第四步:把此对象作为参数代入FutureTask构造器中,并创建futureTask对象
FutureTask<Integer> futureTask = new FutureTask<Integer>(call);
//第五步:再把futureTask对象作为参数代入Thread类构造器中,并创建Thread类对象
Thread thread = new Thread(futureTask);
//设置当前线程名
thread.setName("线程1");
//设置当前线程的优先级
thread.setPriority(10);
//第六步:启动线程,调用call方法(),线程的操作和声明方式放入call()方法中
thread.start();
try {
//获取callable中的call()返回值
//get()返回值即为FutureTask构造器参数Callable实现类重写call()的返回值
Integer o = futureTask.get();
System.out.println("总和:"+o);
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}
}
}
新增方式四:使用线程池
背景:经常创建和销毁,使用量特别大的资源,比如并发的情况下的线程,对性能影响很大。
思路:提前创建好多个线程,放入线程池中,使用时直接获取,使用完放回池中。可以避免频繁创建销毁、实现重复利用。类似生活中的公共交通工具
好处:
- 提高响应速度(减少了创建新线程的时间)
- 降低资源消耗(重复利用线程池中线程,不需要每次都创建)
- 便于线程管理
- corePoolSize:核心池的大小
- maximumPoolSize:最大线程数
- keepAliveTime:线程没有任务时最多保持多长时间后会终止
/**
* 创建线程的方式四:使用线程池
* 好处:
* 1.提高响应速度
* 2.降低资源消耗
* 3.便于线程管理
* corePoolSize:核心池的大小
* maxinumPoolSize:最大线程数
* keepAliveTime:线程没有任务时最多保持多久时间后终止
*/
public class ThreadPool implements Runnable{
@Override
public void run() {
for (int i = 0; i <= 100; i++) {
if(i % 2 == 0){
System.out.println(Thread.currentThread().getName()+":"+ i);
}
}
}
}
class ThreadPool1 implements Runnable{
@Override
public void run() {
for (int i = 0; i <= 100; i++) {
if(i % 2 != 0){
System.out.println(Thread.currentThread().getName()+":"+ i);
}
}
}
}
class ThreadPool2 implements Callable<Integer> {
@Override
public Integer call() throws Exception {
int sum = 0;
for (int i = 0; i <= 100; i++) {
sum += i;
}
return sum;
}
}
class ThreadPollTest{
public static void main(String[] args) {
/**
* 实现Runnable接口
*/
//1.设置指定线程数量的线程池
ExecutorService service = Executors.newFixedThreadPool(10);
ThreadPoolExecutor executor = (ThreadPoolExecutor) service;
//设置线程池的属性
executor.setCorePoolSize(15); //核心池的大小
/* executor.setKeepAliveTime(2022,12);*/
//2.执行指定的线程操作,需要提供实现Runnable接口和Callable接口的实现类的对象
service.execute(new ThreadPool());
service.execute(new ThreadPool1());
/**
* 实现Callable接口
*/
//3.关闭连接池
service.shutdown();
//设置指定线程数量的线程池
ExecutorService server = Executors.newFixedThreadPool(10);
ThreadPoolExecutor executor1 = (ThreadPoolExecutor) server;
//设置当前线程核心池大小
executor1.setCorePoolSize(10);
//指定执行的线程操作,需要提供实现Callable接口的实现类的对象
Future<Integer> submit = executor1.submit(new ThreadPool2());
try {
Integer integer = submit.get();
System.out.println(integer);
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}
System.out.println();
//关闭连接池
executor1.shutdown();
}
}
补充:线程的分类
Java中的线程分为两类:一种是守护线程,一种是用户线程
- 它们在几乎每个方面都是相同的,唯一的区别是判断JVM何时离开。
- 守护线程是用来服务用户线程的,通过start()方法前调用,Thread.setDaemon(true)可以把一个用户线程变成一个守护线程。
- Java垃圾回收就是一个典型的守护线程。
- 若JVM中都是守护线程,当前JVM退出。
线程的声明周期:
JDK中用Thread.State类定义了线程的几种状态
要想实现多线程,必须在主线程中创建新的线程对象。Java语言使用Thread类及其子类的对象来表示线程,在它的一个完整的生命周期通常要经历如下的五种状态:
- 新建:当一个Thread类或其子类的对象被声明并创建时,新生的线程对象处于创建状态。
- 就绪:处于新建状态的线程被start()后,将进入线程队列等待CPU时间片,此时它已具备了运行的条件,只是没分配到CPU资源。
- 运行:当就绪的线程被调度并获得CPU资源时,便进入运行状态,run()方法定义了线程的操作和功能。
- 阻塞:在某种特殊情况下,被认为挂起或执行输入输出操作时,让CPU并临时中止自己的执行,进入阻塞状态。
- 死亡:线程完成了它的全部工作或线程被提前强制性地中止或出现异常导致结束。
解决线程安全问题:
在Java中,我们通过同步机制,来解决线程的安全问题。
方式一:同步代码块:
synchronized(同步监视器){
//需要被同步的代码
}
说明:
1.操作共享数据的代码,即为需要被同步的代码 --->不能包含代码多了,也不能包含代码少了
2.共同数据:多个线程共同操作的变量。比如:ticked就是共享数据。
3.同步监视器,俗称:锁。任何一个类的对象,都可以充当锁。
要求:多个线程必须要共用同一把锁
补充:在实现Runnable接口创建多线程的方式中,我们可以考虑使用this充当同步监视器
同步的方式,解决了线程的安全问题。—好处
操作同步代码时,只能有一个线程参与,其他线程等待。相当于是一个单线程过程—局限性
方式二:同步方法
private synchronized void show(){ //默认有同步监视器
}
同步的方式:解决了线程安全的问题 --- 好处
操作同步代码时,只能有一个线程参与,其他线程等待。相当于是一个单线程过程,效率低。
关于同步方法的总结:
-
同步方法任然涉及到同步监视器,只是不需要我们显示的声明
-
非静态的同步方法,同步监视器是:this
静态的同步方法,同步监视器是:当前类本身 例如:Object.class
方式三:lock锁 ---- JDK5.0新增
1.面试题:synchronized yu lock的异同?
相同:二者都可以解决线程安全问题
不同:synchronized机制在执行完相应的同步代码以后,自动释放同步监视器
lock需要手动的启动同步(lock()),同时结束同步也需要手动的实现(unlock())
2.优先使用顺序:
lock->同步代码块(已经进入了方法体,分配了相应的资源) ->同步方法(在方法体之外)
synchroized与lock的对比
- lock是显示锁(手动开启和关闭锁,别忘记关闭锁),synchroized是隐式锁,出了作用域自动释放。
- lock只有代码块锁,synchronized有代码块锁和方法锁
- 使用lock锁,JVM将花费较少的时间来调度线程,性能更好。并且具有更好的扩展性(提供更多的子类)