1.javaç¼è¯ä¸åºç°äºException in thread âmain" java.lang.UnsupportedClassVersionError
2.线ç¨å¨javaç¼ç¨ä¸çä½ç¨
3.详解java Thread中的join方法
4.JAVA如何获取jvm中的所有线程?
5.老生常谈线程基础的几个问题
javaç¼è¯ä¸åºç°äºException in thread âmain" java.lang.UnsupportedClassVersionError
è¿ä¸ªé®é¢ç¡®å®æ¯ç±è¾é«çæ¬çJDKç¼è¯çjava classæ件è¯å¾å¨è¾ä½çæ¬çJVMä¸è¿è¡äº§ççé误ã1ã解å³æªæ½å°±æ¯ä¿è¯jvmï¼javaå½ä»¤ï¼åjdkï¼javacå½ä»¤ï¼çæ¬ä¸è´ãå¦ææ¯linuxçæ¬ï¼åå¨å½ä»¤è¡ä¸åå«è¾å ¥java -versionåjavac -versionå½ä»¤æ¥æ¥ççæ¬æ¯å¦ä¸è´ãè¿éå设é½æ¯1.7çæ¬ã
2ãå¦æé½ä¸è´ï¼ä½è¿æ¯è§£å³ä¸äºé®é¢ï¼é£ä¹ä½ è¯å®ä¸æ¯ç´æ¥å¨å½ä»¤è¡ä¸ç¨javacæ¥ç¼è¯çï¼èæ¯ç¨ç±»ä¼¼äºeclipseãnetbeansè¿æ ·çç¼è¯å¨æ¥ç¼è¯çãå 为å¾å¤ç¼è¯å¨é½èªå¸¦javacï¼èä¸æ¯éç¨æä½ç³»ç»ä¸çç¼è¯å¨ãå¦æä½ çç¼è¯å¨æ¯eclipseçè¯ï¼é£ä¹éè¦å¨é¡¹ç®çå±æ§é设置jdkçæ¬ï¼æ¹æ³æ¯å³å»é¡¹ç®-->properties-->java compiler --> Enable project specific settings -->å°compiler compliance level设置为1.7ï¼ä¹å°±æ¯ä¸jvmä¸è´ççæ¬ï¼å¨å½ä»¤è¡ä¸java -versionææ¾ç¤ºççæ¬ï¼ã
综ä¸ï¼å¦æä½ æ¯ç¨ç¼è¯å¨æ¥ç¼è¯çè¯ï¼è¯·é¦å ç¡®ä¿ç¼è¯å¨èªå¸¦çjdkçæ¬æ¯å¦åæä½ç³»ç»ä¸çjavaçæ¬ä¸è´ã
è§ä¸å¾ï¼
线ç¨å¨javaç¼ç¨ä¸çä½ç¨
ãã线ç¨å¨javaç¼ç¨ä¸çä½ç¨å¯ä»¥å®ç°å¤ä¸ªä»»å¡åæ¶è¿è¡ãjavaå建线ç¨çæ¹å¼æ常ç¨çæ两ç§ããã1ã第ä¸ç§æ¯å建Threadåç±»çä¸ä¸ªå®ä¾å¹¶éårunæ¹æ³ï¼runæ¹æ³ä¼å¨è°ç¨start()æ¹æ³ä¹å被æ§è¡ãä¾åå¦ä¸ï¼
public class MyThread extends Thread {public void run(){
System.out.println("MyThread running");
}
}
MyThread myThread = new MyThread();
myTread.start();
2ã第äºç§ç¼å线ç¨æ§è¡ä»£ç çæ¹å¼æ¯æ°å»ºä¸ä¸ªå®ç°äºjava.lang.Runnableæ¥å£çç±»çå®ä¾ï¼å®ä¾ä¸çæ¹æ³å¯ä»¥è¢«çº¿ç¨è°ç¨ãä¸é¢ç»åºä¾åï¼
public class MyRunnable implements Runnable {public void run(){
System.out.println("MyRunnable running");
}
}
Thread thread = new Thread(new MyRunnable());
thread.start();
详解java Thread中的join方法
在Java编程中,Thread类的join()方法发挥着关键作用。当需要控制线程执行顺序时,它能让调用线程暂停,直至被调用的线程完成。在主线程(如main())中,c 源码怎么查看join()尤其有用,它会阻止主线程直到目标线程结束,例如:
当调用t1.join()时,main()线程会被暂停,直到t1线程完全执行完毕,然后main()线程才会继续执行。
join()方法的工作原理主要依赖于Java内存模型中的同步机制。通过查看Thread类的源码,我们发现join()实际上调用了wait()方法,使调用线程进入等待状态,直到目标线程结束。由于wait()方法前有synchronized修饰,这意味着主线程(t1线程的持有者)会在一个锁定的上下文中等待,如下所示:
代码等效于:synchronized(this) { wait(); },使得主线程进入等待队列,直到t1线程结束。
然而,wait()方法本身并不会唤醒主线程,唤醒过程隐藏在Java虚拟机(JVM)的底层。当t1线程执行完毕,crond 源码 解析JVM会自动调用lock.notify_all()方法,将主线程从等待队列中唤醒。
总结起来,join()方法的使用需要注意以下两点:
1. 它让调用线程暂停,直到目标线程结束。
2. 唤醒机制由JVM内部的notify_all()方法控制,确保线程按照预期顺序执行。
理解这些原理,能帮助你更有效地管理和控制Java线程。
JAVA如何获取jvm中的所有线程?
在Java中,你可以通过Java的java.lang.management包获取JVM中的所有线程。这个包提供了一些用于管理和监视Java虚拟机的工具。具体来说,你可以使用ThreadMXBean接口来获取线程信息。
以下是一段示例代码,演示如何获取和打印JVM中的所有线程:
java复制代码
import java.lang.management.ManagementFactory;
import java.lang.management.ThreadInfo;
import java.lang.management.ThreadMXBean;
public class Main {
public static void main(String[] args) {
// 获取ThreadMXBean
ThreadMXBean threadMXBean = ManagementFactory.getThreadMXBean();
// 不需要获取同步的monitor和synchronizer信息,仅获取线程和线程堆栈信息
ThreadInfo[] threadInfos = threadMXBean.dumpAllThreads(false, false);
// 遍历线程信息,仅打印线程ID和线程名称信息
for (ThreadInfo threadInfo : threadInfos) {
System.out.println("[" + threadInfo.getThreadId() + "] " + threadInfo.getThreadName());
}
}
}
这段代码首先通过ManagementFactory.getThreadMXBean()获取ThreadMXBean实例,然后调用dumpAllThreads()方法获取所有线程的ThreadInfo,最后遍历并打印所有线程的ID和名称。
需要注意的是,dumpAllThreads()方法会返回一个ThreadInfo数组,每个ThreadInfo代表一个线程,包含了关于该线程的大量信息,包括线程ID、adaboost算法 源码线程名称、线程状态、线程堆栈信息等。在上面的示例代码中,我们只打印了线程ID和线程名称,但你可以根据需要打印其他信息。
老生常谈线程基础的几个问题
实现线程只有一种方式
我们知道启动线程至少可以通过以下四种方式:
实现Runnable接口
继承Thread类
线程池创建线程
带返回值的Callable创建线程
但是看它们的底层就一种方式,就是通过newThread()实现,其他的只不过在它的上面做了层封装。
实现Runnable接口要比继承Thread类的更好:
结构上分工更明确,线程本身属性和任务逻辑解耦。
某些情况下性能更好,直接把任务交给线程池执行,无需再次newThread()。
可拓展性更好:实现接口可以多个,而继承只能单继承。
有的时候可能会问到启动线程为什么是start()方法,而不是run()方法,这个问题很简单,执行run()方法其实就是在执行一个类的普通方法,并没有启动一个线程,而start()方法点进去看是一个native方法。
当我们在执行java中的start()方法的时候,它的底层会调JVM由c++编写的代码Thread::start,然后c++代码再调操作系统的learun 6.3 源码create_thread创建线程,创建完线程以后并不会马上运行,要等待CPU的调度。CPU的调度算法有很多,比如先来先服务调度算法(FIFO),最短优先(就是对短作业的优先调度)、时间片轮转调度等。如下图所示:
线程的状态在Java中线程的生命周期中一共有6种状态。
NEW:初始状态,线程被构建,但是还没有调用start方法
RUNNABLE:运行状态,JAVA线程把操作系统中的就绪和运行两种状态统一称为运行中
BLOCKED:阻塞状态,表示线程进入等待状态,也就是线程因为某种原因放弃了CPU使用权
WAITING:等待状态
TIMED_WAITING:超时等待状态,超时以后自动返回
TERMINATED:终止状态,表示当前线程执行完毕
当然这也不是我说的,源码中就是这么定义的:
publicenumState{ /***Threadstateforathreadwhichhasnotyetstarted.*/NEW,/***Threadstateforarunnablethread.Athreadintherunnable*stateisexecutingintheJavavirtualmachinebutitmay*bewaitingforotherresourcesfromtheoperatingsystem*suchasprocessor.*/RUNNABLE,/***Threadstateforathreadblockedwaitingforamonitorlock.*Athreadintheblockedstateiswaitingforamonitorlock*toenterasynchronizedblock/methodor*reenterasynchronizedblock/methodaftercalling*{ @linkObject#wait()Object.wait}.*/BLOCKED,/***Threadstateforawaitingthread.*Athreadisinthewaitingstateduetocallingoneofthe*followingmethods:*<ul>*<li>{ @linkObject#wait()Object.wait}withnotimeout</li>*<li>{ @link#join()Thread.join}withnotimeout</li>*<li>{ @linkLockSupport#park()LockSupport.park}</li>*</ul>**<p>Athreadinthewaitingstateiswaitingforanotherthreadto*performaparticularaction.**Forexample,athreadthathascalled<tt>Object.wait()</tt>*onanobjectiswaitingforanotherthreadtocall*<tt>Object.notify()</tt>or<tt>Object.notifyAll()</tt>on*thatobject.Athreadthathascalled<tt>Thread.join()</tt>*iswaitingforaspecifiedthreadtoterminate.*/WAITING,/***Threadstateforawaitingthreadwithaspecifiedwaitingtime.*Athreadisinthetimedwaitingstateduetocallingoneof*thefollowingmethodswithaspecifiedpositivewaitingtime:*<ul>*<li>{ @link#sleepThread.sleep}</li>*<li>{ @linkObject#wait(long)Object.wait}withtimeout</li>*<li>{ @link#join(long)Thread.join}withtimeout</li>*<li>{ @linkLockSupport#parkNanosLockSupport.parkNanos}</li>*<li>{ @linkLockSupport#parkUntilLockSupport.parkUntil}</li>*</ul>*/TIMED_WAITING,/***Threadstateforaterminatedthread.*Thethreadhascompletedexecution.*/TERMINATED;}下面是这六种状态的转换:
New新创建New表示线程被创建但尚未启动的状态:当我们用newThread()新建一个线程时,如果线程没有开始调用start()方法,那么此时它的状态就是New。而一旦线程调用了start(),它的状态就会从New变成Runnable。
Runnable运行状态Java中的Runable状态对应操作系统线程状态中的两种状态,分别是Running和Ready,也就是说,Java中处于Runnable状态的线程有可能正在执行,也有可能没有正在执行,正在等待被分配CPU资源。dnf挂机源码
如果一个正在运行的线程是Runnable状态,当它运行到任务的一半时,执行该线程的CPU被调度去做其他事情,导致该线程暂时不运行,它的状态依然不变,还是Runnable,因为它有可能随时被调度回来继续执行任务。
在Java中Blocked、Waiting、TimedWaiting,这三种状态统称为阻塞状态,下面分别来看下。
Blocked从上图可以看出,从Runnable状态进入Blocked状态只有一种可能,就是进入synchronized保护的代码时没有抢到monitor锁,jvm会把当前的线程放入到锁池中。当处于Blocked的线程抢到monitor锁,就会从Blocked状态回到Runnable状态。
Waiting状态我们看上图,线程进入Waiting状态有三种可能。
没有设置Timeout参数的Object.wait()方法,jvm会把当前线程放入到等待队列。
没有设置Timeout参数的Thread.join()方法。
LockSupport.park()方法。
Blocked与Waiting的区别是Blocked在等待其他线程释放monitor锁,而Waiting则是在等待某个条件,比如join的线程执行完毕,或者是notify()/notifyAll()。
当执行了LockSupport.unpark(),或者join的线程运行结束,或者被中断时可以进入Runnable状态。当调用notify()或notifyAll()来唤醒它,它会直接进入Blocked状态,因为唤醒Waiting状态的线程能够调用notify()或notifyAll(),肯定是已经持有了monitor锁,这时候处于Waiting状态的线程没有拿到monitor锁,就会进入Blocked状态,直到执行了notify()/notifyAll()唤醒它的线程执行完毕并释放monitor锁,才可能轮到它去抢夺这把锁,如果它能抢到,就会从Blocked状态回到Runnable状态。
TimedWaiting状态在Waiting上面是TimedWaiting状态,这两个状态是非常相似的,区别仅在于有没有时间限制,TimedWaiting会等待超时,由系统自动唤醒,或者在超时前被唤醒信号唤醒。
以下情况会让线程进入TimedWaiting状态。
设置了时间参数的Thread.sleep(longmillis)方法。
设置了时间参数的Object.wait(longtimeout)方法。
设置了时间参数的Thread.join(longmillis)方法。
设置了时间参数的LockSupport.parkNanos(longnanos)。
LockSupport.parkUntil(longdeadline)方法。
在TimedWaiting中执行notify()和notifyAll()也是一样的道理,它们会先进入Blocked状态,然后抢夺锁成功后,再回到Runnable状态。当然,如果它的超时时间到了且能直接获取到锁/join的线程运行结束/被中断/调用了LockSupport.unpark(),会直接恢复到Runnable状态,而无需经历Blocked状态。
Terminated终止Terminated终止状态,要想进入这个状态有两种可能。
run()方法执行完毕,线程正常退出。
出现一个没有捕获的异常,终止了run()方法,最终导致意外终止。
线程的停止interrupt我们知道Thread提供了线程的一些操作方法,比如stop(),suspend()和resume(),这些方法已经被Java直接标记为@Deprecated,这就说明这些方法是不建议大家使用的。
因为stop()会直接把线程停止,这样就没有给线程足够的时间来处理想要在停止前保存数据的逻辑,任务戛然而止,会导致出现数据完整性等问题。这种行为类似于在linux系统中执行kill-9类似,它是一种不安全的操作。
而对于suspend()和resume()而言,它们的问题在于如果线程调用suspend(),它并不会释放锁,就开始进入休眠,但此时有可能仍持有锁,这样就容易导致死锁问题,因为这把锁在线程被resume()之前,是不会被释放的。
interrupt最正确的停止线程的方式是使用interrupt,但interrupt仅仅起到通知被停止线程的作用。而对于被停止的线程而言,它拥有完全的自主权,它既可以选择立即停止,也可以选择一段时间后停止,也可以选择压根不停止。
下面我们来看下例子:
publicclassInterruptExampleimplementsRunnable{ //interrupt相当于定义一个volatile的变量//volatilebooleanflag=false;publicstaticvoidmain(String[]args)throwsInterruptedException{ Threadt1=newThread(newInterruptExample());t1.start();Thread.sleep(5);//Main线程来决定t1线程的停止,发送一个中断信号,中断标记变为truet1.interrupt();}@Overridepublicvoidrun(){ while(!Thread.currentThread().isInterrupted()){ System.out.println(Thread.currentThread().getName()+"--");}}}执行一下,运行了一会就停止了
主线程在调用t1的interrupt()之后,这个线程的中断标记位就会被设置成true。每个线程都有这样的标记位,当线程执行时,会定期检查这个标记位,如果标记位被设置成true,就说明有程序想终止该线程。在while循环体判断语句中,通过Thread.currentThread().isInterrupt()判断线程是否被中断,如果被置为true了,则跳出循环,线程就结束了,这个就是interrupt的简单用法。
阻塞状态下的线程中断下面来看第二个例子,在循环中加了Thread.sleep秒。
publicclassInterruptSleepExampleimplementsRunnable{ //interrupt相当于定义一个volatile的变量//volatilebooleanflag=false;publicstaticvoidmain(String[]args)throwsInterruptedException{ Threadt1=newThread(newInterruptSleepExample());t1.start();Thread.sleep(5);//Main线程来决定t1线程的停止,发送一个中断信号,中断标记变为truet1.interrupt();}@Overridepublicvoidrun(){ while(!Thread.currentThread().isInterrupted()){ try{ Thread.sleep();}catch(InterruptedExceptione){ //中断标记变为falsee.printStackTrace();}System.out.println(Thread.currentThread().getName()+"--");}}}再来看下运行结果,卡主了,并没有停止。这是因为main线程调用了t1.interrupt(),此时t1正在sleep中,这时候是接收不到中断信号的,要sleep结束以后才能收到。这样的中断太不及时了,我让你中断了,你缺还在傻傻的sleep中。
Java开发的设计者已经考虑到了这一点,sleep、wait等方法可以让线程进入阻塞的方法使线程休眠了,而处于休眠中的线程被中断,那么线程是可以感受到中断信号的,并且会抛出一个InterruptedException异常,同时清除中断信号,将中断标记位设置成false。
这时候有几种做法:
直接捕获异常,不做处理,e.printStackTrace();打印下信息
将异常往外抛出,即在方法上throwsInterruptedException
再次中断,代码如下,加上Thread.currentThread().interrupt();
@Overridepublicvoidrun(){ while(!Thread.currentThread().isInterrupted()){ try{ Thread.sleep();}catch(InterruptedExceptione){ //中断标记变为falsee.printStackTrace();//把中断标记修改为trueThread.currentThread().interrupt();}System.out.println(Thread.currentThread().getName()+"--");}}这时候线程感受到了,我们人为的再把中断标记修改为true,线程就能停止了。一般情况下我们操作线程很少会用到interrupt,因为大多数情况下我们用的是线程池,线程池已经帮我封装好了,但是这方面的知识还是需要掌握的。感谢收看,多多点赞~
作者:小杰博士