java thread用法,关于java中thread类提供的控制方法
00-1010一、螺纹的常用施工方法二。线程III的常见属性。正在创建线程IV。中断线程v，等待线程VI。获取线程引用VII。睡眠线程八。总结线程状态。
00-1010方法描述Thread()创建Thread对象Thread (Runnable target)用Runnable对象创建Thread对象Thread(String name)创建Thread对象并命名Thread(Runnable target，String name)用Runnable对象创建Thread对象并命名关于前两种方法，在前面的线程创建介绍中使用过。
创建线程基本上有两种方法：
创建一个继承自Thread类的子类，在Thread中重写run方法，调用start方法创建一个实现runnable接口的类，在Thread中重写Run方法。创建一个thread实例，设置你写的实现Runnable接口的类的实例，调用start方法构造方法三和方法四，但只是在前两个构造方法的基础上增加一个为Thread对象命名的参数，方便程序员调试。
代码(以施工方法4为例):
public class func 7 { public static void main(String[]args){ Thread Thread=new Thread(()-{ while(true){ system . out . println(这是我的线程)；试试{ thread . sleep(1000)；} catch(interrupted exception e){ e . printstacktrace()；} } }， myThread )；//这里用lambda表达式代替Runnable实例，更简洁。增加一个参数指定线程thread的名称thread . start()；while(true){ system . out . println( my main )；试试{ thread . sleep(1000)；} catch(interrupted exception e){ e . printstacktrace()；}}}}程序员可以通过JDK附带的jconsole工具直观地查看这里创建的线程。
第一步：
运行程序后，找到自己的jdk路径——bin-jconsole . exe
第二步：双击exe文件。选择本地流程。这里列出了Java进程。你可以看到我们的程序func7，点击它。在菜单栏中选择“螺纹”栏。
第三步：检查线程信息。
可以选择左边要查看的线程，可以看到主线程main和新创建的线程myThread。如果没有重命名操作，新创建的线程会被命名为Thread-0和Thread-1，不方便查看。
右侧显示线程被读取时的状态，堆栈跟踪显示代码的具体执行位置。
00-1010属性方法IDgetId()name getName()status getState()priority get priority()是后台线程isDaemon () isAlive，isalive () isInterrupted()解释：
线程的唯一标识是线程Id名反映在上面的案例中，为调试提供了方便。状态指示线程的当前情况。在上面的例子中，线程进入阻塞状态是因为它调用了sleep方法。优先级表示线程被调度的难度，越高越容易被调度，以此来判断是否是后台线程。如果是后台线程，后台线程不会影响java进程的结束；如果是非后台线程，JVM会一直等到所有非后台线程都结束，所以会影响总进程的结束是否存活。这是判断线程是否仍然存在的一种方法。创建线程实例对象时，线程不一定是创建的，需要调用。
start 方法，才是真正的创建了线程。当线程中的 run 方法执行完毕，线程结束被销毁了，创建出的实例对象还没被销毁回收。所以说，创建出的实例对象和线程的生命周期是不完全相同的在线程的状态中，除了NEW 和 TERMINATED 以外的状态都是活着的
代码：
public class func8 { public static void main(String[] args) { Thread t = new Thread(()->{ for (int i = 0;i < 5;i ++) { System.out.println("新线程~"); try { Thread.sleep(2000); } catch (InterruptedException e) { e.printStackTrace(); } } },"newThread"); System.out.println("新线程状态：" +t.getState()); //创建了对象，没创建线程 t.start(); System.out.println("新线程状态：" +t.getState()); //创建了线程 System.out.println("新线程Id："+t.getId()); System.out.println("新线程名称："+t.getName()); System.out.println("新线程是否为后台线程：" + t.isDaemon()); System.out.println("新线程是否被中断：" + t.isInterrupted()); System.out.println("新线程优先级：" + t.getPriority()); System.out.println("主线程名称："+Thread.currentThread().getName()); while (t.isAlive()) {} //当t线程还存在时，主线程就搁这儿循环着，直到线程结束 System.out.println("新线程状态：" +t.getState());//线程结束 }}结果：
三、创建线程
创建 Thread 类的对象不意味着线程被创建出，start() 方法才是真正的在操作系统内部创建一个新的线程，通过重写 run 方法来描述需要执行的任务，从而真正实现了多线程运行。
四、中断线程
方法一：手动设置标志位，作为中断线程的条件
public class func9 { private static Boolean flag = false;//手动设置的标志位 flag public static void main(String[] args) { Thread t = new Thread(() -> { while (!flag) { //flag 为真时停止循环 System.out.println("myThread"); try { Thread.sleep(1000);//打印一次，阻塞一秒 } catch (InterruptedException e) { e.printStackTrace(); } } }); t.start();//创建了线程 t try { Thread.sleep(3000); } catch (InterruptedException e) { e.printStackTrace(); } flag = true; //等3秒后，在主线程中将 flag 的值改成 true，从而使线程t循环条件不成立 }}方法二：使用 Thread 实例中的标志位
public class func10 { public static void main(String[] args) { Thread t = new Thread() { @Override public void run() { //通过 isInerrupted()判断标志位是否为true，为true说明线程要退出 while (!this.isInterrupted()) { System.out.println("my Thread"); try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); //System.out.println("完善工作"); //break; } } } }; t.start();//创建新的线程 try { Thread.sleep(3000); } catch (InterruptedException e) { e.printStackTrace(); } t.interrupt(); //t线程运行3秒后，通过 interrupt() 方法将标志位设置为 true }}结果：
可以看见当3秒后标志位设置为 true，希望 t 线程中断退出时，结果只是报了个 InterruptedException 异常。
事实上，当调用 interrupt 方法时，如果线程为就绪状态，就会直接修改线程中的标志位；如果是阻塞状态，就会引起 InterruptedException 异常（因为调用了 sleep 方法，正阻塞着呢，结果被强行呼醒了）
但收到中断线程这个信号后，出现了异常，只是单纯的打印了一下异常，并没有对出现的异常进行反应，于是 t 线程就继续循环，就好像中断线程这个信号只是提醒了一下，线程打个日志就完事，当做没听见。
事实上，这样的机制是有存在的道理的，如果调用了 interrupt 方法后，线程说中断就中断，是非常不符合常理的，此时并不知道线程执行到什么地方，收到中断的信号后，怎么说也要进行收尾工作，由线程自己决定什么时候被销毁
因此我们要在捕捉到 InterruptedException 异常后，进行工作完善，然后通过 break 跳出循环，结束线程
方法二和方法一相比更加好。因为方法一中的中断标志被修改后，即使当时正在 sleep ，也会把当下的 sleep 的时间过完，才会进行下一轮判断，才知道线程被中断。方法二即使是在 sleep，收到中断信号后，就会马上被唤醒，中断信息收到的更加的及时。
结果：
五、线程等待
通过join() 方法来决定线程执行顺序（主要控制结束线程的顺序）。
public class func11 { public static void main(String[] args) throws InterruptedException { Thread t1 = new Thread(() -> { for (int i = 0;i < 3;i ++) { System.out.println("my Thread~~"); try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } } }); t1.start(); //t1.join(); for (int i = 0;i < 3;i ++) { System.out.println("my main!!"); try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } } }}结果：
在没有调用 join 方法时，main 线程和 t1 线程是并发的，结果输出是相间的。调用 join 方法后，main 线程就会阻塞等待，要等 t1 线程执行完毕，才会执行 join 方法后的内容
不带参数的 join 方法，等待结束的条件就是 t1 线程结束，没结束就会一直死等；该方法也可以带参数，通过参数来指定等待时间
六、获取线程引用
在线程代码中，需要获取当前线程对应的 Thread 类的实例化对象，才能进行更多的操作
方法一：通过继承 Thread 类创建的线程，可以在重写的 run 方法中通过 this 获取当前线程的实例
在上面的中断线程中的方法二中就是通过 this.isInterrupted() 来获取当前实例是否被中断的信息。
如果将创建线程的方式改成创建 Runnable 实例的方法，当前的run 方法就不是 Thread 类的方法，this 指向的是 Runnable，就没有办法获取 Thread 实例，更没有办法使用其中的方法
方法二：通过 Thread 类的 currentThread() 方法，哪个线程调用了该方法，就返回哪个线程的实例对象
七、线程休眠
该方法在前面经常介绍，那就是 sleep 方法
一旦调用 sleep 方法，线程就会阻塞等待，等待的时间取决于指定的参数
操作系统是以线程为单位进行调度的，每个线程都对应着一个 PCB，并通过双向链表组织这些 PCB
操作系统调度 PCB 时，就是从就绪队列中选出一个 PCB 去 CPU 上执行，当执行着的线程调用了 sleep 方法，这个 PCB 就会被移动到阻塞队列中，等到 sleep 的时间到了，就会回到就绪队列中，准备好被执行
join 方法也会产生阻塞等待，就像线程等待中的例子，main 线程执行到 join方法后，就到阻塞队列中，等待对应的 t1 线程执行完毕，才会回到就绪队列中，做好被执行的准备
八、线程状态
从之前的 Thread 的常见属性这里的代码案例可以看出来线程的状态不只是就绪和阻塞，即使是阻塞也分成好几种阻塞类型
//线程的状态是一个枚举类型 Thread.State//打印 Java 线程中的所有状态public class func13 { public static void main(String[] args) { for (Thread.State state : Thread.State.values()) { System.out.println(state); } }}结果：
NEW：表示 Thread 类的对象创建出，但是线程还没有被创建，即没有调用 start 方法RUNNABLE：就绪状态BLOCKED：等待锁时的状态（期待下一篇关于线程安全的博客）WAITING：通过 wait 方法触发（期待之后的博客）TIMED_WAITING：通过 sleep 方法产生TERMINATED：线程已经执行完毕，但 Thread 类的对象还存在，未被销毁
总结
到此这篇关于Java中Thread类详解及常用的方法的文章就介绍到这了,更多相关JavaThread类方法内容请搜索盛行IT以前的文章或继续浏览下面的相关文章希望大家以后多多支持盛行IT！
郑重声明：本文由网友发布，不代表盛行IT的观点，版权归原作者所有，仅为传播更多信息之目的，如有侵权请联系，我们将第一时间修改或删除，多谢。