java中thread用法,java thread的方法有哪些
00-1010方法1:继承Thread类方法2:在Runnable接口中实现run()方法方法3:使用内部类方法4:使用lambmd表达式使用Thread类的其他属性和方法来命名一个线程以判断一个线程是否存活线程的其他公共属性创建线程的中断线程等待线程的引用线程休眠。java可以进行多线程编程，java标准库中提供了一个线程类。thread类Thread类可以看作是java标准库提供的一套解决多线程编程的API。
创建的线程实例对应于操作系统中的线程。操作系统提供关于线程的API(C语言风格)，java将其封装成线程类。
目录
00-1010类my thread扩展thread { @ override public void run(){//此时只定义了一个thread类来处理，系统中没有创建新的线程。system . out . println( hello thread )；} } public class test demo 11 { public static void main(string[]args){//Create Thread Thread t=new MyThread()；//启动线程，在系统中新建一个线程t . Start()；}}
线程之间是并发执行的
class Thread 3 extends Thread { @ override public void run(){//定义一个线程类while(true){ system . out . println( Hello Thread )；试试{ thread . sleep(1000)；} catch(interrupted exception e){ e . printstacktrace()；} } } }公共类test demo 13 { public static void main(String[]args){ Thread t=new myth read 3()；t . start()；//启动T线程while(true){ system . out . println( Hello Main )；试试{ thread . sleep(1000)；} catch(interrupted exception e){ e . printstacktrace()；} } }}
我们可以看到1s在一个线程中执行完代码后进入阻塞状态，那么下一秒应该唤醒哪个线程呢？
我们可以看到，在两个执行的线程中打印日志的顺序是不确定的。每一轮，1s后，不确定是唤醒线程还是主线程。(抢占式执行)，对于操作系统来说，从宏观角度调度线程的顺序是随机的。
这里解释一下Thread.sleep()方法。sleep()方法在ms级别上不太准确。当调用这个方法时，线程被强制阻塞(睡眠状态)，但是当阻塞时间结束时，线程不会立即在cup上执行。如果Thread.sleep(1000)过了1s，那么阻塞时间结束，但是在1001ms内，线程可能不会立即执行。可能操作系统中的CPU正忙于其他线程。可能线程只执行了1006 ms。
00-1010//Runnable实际描述的是一个任务。//创建一个类，实现Runnable接口，在Runnable类中重写run方法。在run()方法中，它描述了线程将指向哪些任务。类MyThread2实现Runnable { @ Override public void run(){
System.out.println("hello thread"); }}public class TestDemo12 { public static void main(String[] args) { //创建线程，把创建好的Runnable实例传给Thread实例 Thread t = new Thread(new MyThread2()); t.start(); }}
方法三：利用内部类
方法三其实是方法一个的翻版，就是把上面的两种代码，改成了匿名内部类。
public class TestDemo14 { public static void main(String[] args) { Thread t1 = new MyThread(){ @Override public void run() { System.out.println("hello thread1"); } }; Thread t2 = new Thread(new Runnable() { @Override public void run() { System.out.println("hello thread2"); } }); t1.start(); t2.start(); }}
方法四：使用lambmd表达式
public class TestDemo15 { public static void main(String[] args) { //其实就是使用lambad表达式代替Runnable Thread t1 = new Thread(()->{ //()表示无参的run()方法 System.out.println("hello thread1"); }); }}
使用线程的好处
为了更方便的体现出多线程的好处，在这里我们从0开始自增1，一直自增到10_0000_0000，使用串行方法，和并行方法，并且获取他们执行代码的时间，进行比较。
public class TestDemo16 { public static void func1() throws InterruptedException { long big = System.currentTimeMillis(); //串行执行 Thread t = new Thread(()->{ long a = 0; for(long i = 0;i<10_0000_0000;i++){ a++; } }); t.start(); t.join(); long end = System.currentTimeMillis(); System.out.println("串行消耗时间:" + (end - big) + "ms"); } public static void func2() throws InterruptedException { long big = System.currentTimeMillis(); Thread t1 = new Thread(()->{ long b = 0; for(long i = 0;i< 10_0000_0000 / 2;i++){ b++; } }); t1.start(); Thread t2 = new Thread(()->{ long c = 0; for(long i = 0;i<10_0000_0000/ 2;i++){ c++; } }); t2.start(); t1.join(); t2.join(); long end = System.currentTimeMillis(); System.out.println("并行执行消耗时间:" + (end - big) + "ms"); } public static void main(String[] args) throws InterruptedException { func1();//串行执行 func2();//并行执行 }}
我们可以很明显的看出串行时间要比并行时间长的多，串行时间几乎是并行时间的2倍。
Thread类的其他属性和方法
Thread的常见构造方法
属性获取方法IDgetId()名称getName()状态getState()优先级getPriority()是否后台线程isDaemon()线程是否存活isAlive()线程是否被中断isinterrupted()ID是线程唯一的标识，不同的线程之间不会重复名称是各种调试工具用到的状态标识当前线程的一种情况优先级高的线程，理论上更容易被执行到是否存活简单理解为run()方法是否执行结束
给一个线程起名字
Thread(String name) 这个东西是给thread对象起一个名字，具体起什么名字和线程的执行效率无关，起名字主要依靠于程序员，方便程序员在后期进行调试。
public class TestDemo17 { public static void main(String[] args) { //给线程器名字 Thread t1 = new Thread(()->{ while(true) { System.out.println("hello thread1"); try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } } },"thread1"); Thread t2 = new Thread(()->{ while(true) { System.out.println("hello thread2"); try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } } },"thread2"); t1.start(); t2.start(); }}那么怎样才能看到，我们定义好的线程名字呢？
注意：当我们要查看线程名字的时候，程序必须要正在执行，否则我们查找不到对应的线程名字。
判断一个线程是否存活
简单的说就是操作系统中我们创建出来的线程是否还存在
Thread t 的生命周期和操作系统中对应的线程的生命周期并不是完全一致的。
我们在定义一个线程类后，在调用t.start()方法之前，操作系统中是没有我们创建出来的线程的。在线程类中的run()方法执行完之后，我们在操作系统中创建出来的线程就被销毁了！但是线程t对象还存在。
总而言之，在调用t.start()方法之前，在执行run()方法之后，此时操作系统中是没有我们创建出来的线程的。在调用t.start()方法之后，在指向run()方法之前，此时操作系统中存在我们创建出来的线程 判断该线程是由是后台线程
如果一个线程是后台线程，那么这个线程就不会进行进程退出
如果一个线程是前台线程，那么这个这个线程就会影响到进程的退出。我们以上的代码在创建线程，那些线程都是前台线程，假如现在有前台线程t1,t2， 现在即使main线程执行结束，但是此时还不可以退出线程，必须要将t1,t2线程执行结束之后，整个线程才会结束。
假如现在有两个线程t1,t2，它们都是后台线程，那么如果现在main线程执行结束，整个进程就执行结束，此时我们会强制停止t1,t2线程。
public class TestDemo18 { public static void main(String[] args) { Thread t = new Thread(()->{ System.out.println("hello thread"); }); t.start(); System.out.println(t.isDaemon()); }}//因为我们创建的是一个前台线程，所以返回false
Thread的其他常见属性
创建线程
创建线程：定义出一个线程类，然后启动线程t.start(),其中start()方法决定系统是不是真的创建出线程。
线程的中断
中断线程简单的可以理解成为就是让该线程中的run()方法执行结束。还有一个特殊的就是main线程，如果想要中断main线程，那么就需要把main线程执行完。
中断线程方法一：设置一个标志位
public class TestDemo21 { public static void main(String[] args) { Thread t = new Thread(()->{ while(!Thread.currentThread().isInterrupted()) { System.out.println("hello thread"); try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } } }); //启动t线程 t.start(); //在main线程中中断t线程 //5s之后中断t线程 try { Thread.sleep(5000); } catch (InterruptedException e) { e.printStackTrace(); } t.interrupt(); }}运行结果：当t线程中的sout语句被执行5次之后，线程停止。
上面的这种写法不够严谨，只适用于该场合，如果化作是别的代码场合的话，有可能不会终止线程。
这里用一种较好的方法，使用Thread类中自带的检查线程是否断开。
Thread.interrputed() 这是一个静态方法 Thread.currentThread().isinterrupted() 其中Thread.cerrentThread()可以获得线程的引用。
t.interrupted()用于中断线程
public class TestDemo21 { public static void main(String[] args) { Thread t = new Thread(()->{ while(!Thread.currentThread().isInterrupted()) { System.out.println("hello thread"); try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } } }); //启动t线程 t.start(); //在main线程中中断t线程 //5s之后中断t线程 try { Thread.sleep(5000); } catch (InterruptedException e) { e.printStackTrace(); } t.interrupt(); }}
在我们上边中断线程，判断标志位的时候，我们使用的是第三种方法。设置标志位的时候使用的是第一种方法。
在我们的日常开发中，经常会用到Thread.currentThread().isInterrupted()来判断标志位，判断该线程是否被中断。
还有一种方法判断标志位，但是它是一个静态方法，只能判断一个类中只有一个线程的情况下，这个方法就是Thread.isinterrupted()方法。
Thread.currentThread().isinterrupted()这个方法判断的是Thread的普通成员，每个实例都有一个标志位。
在我们以后就无脑使用Thread.currentThread().isInterrupted()方法，判断线程是否中断(标志位)
线程的等待
在前面我们也介绍到join()方法，这个方法就是让线程与线程之间，有了一定的执行顺序。我们知道在多线程中的调度是随机的，不确定的，多线程的执行靠调度器安排，该调度器的安排是随机的，不规律的。其实线程等待就是一个行之有效的方法，实际上就是控制线程执行的先后顺序。
public class TestDemo22 {<!--{C}%3C!%2D%2D%20%2D%2D%3E--> public static void main(String[] args) throws InterruptedException {<!--{C}%3C!%2D%2D%20%2D%2D%3E--> Thread t = new Thread(()->{<!--{C}%3C!%2D%2D%20%2D%2D%3E--> for(int i = 0;i<5;i++){<!--{C}%3C!%2D%2D%20%2D%2D%3E--> System.out.println("hello thread"); try {<!--{C}%3C!%2D%2D%20%2D%2D%3E--> Thread.sleep(1000); } catch (InterruptedException e) {<!--{C}%3C!%2D%2D%20%2D%2D%3E--> e.printStackTrace(); } } }); t.start(); t.join();//main线程调用t.join()方法，main线程就处于阻塞状态，当t线程执行完后，唤醒main线程执行后序代码 System.out.println("hello main"); }}
获取线程的引用
使用方法Thread.currentTread()就可以该线程的实例。
public class TestDemo23 { public static void main(String[] args) { Thread t = new Thread(){ @Override public void run() { //获取当前线程的引用 //System.out.println(Thread.currentThread().getName()); //因为当前使用的匿名内部类是继承自Thread类，Thread就是该匿名内部类的父类，所以可以通过this得到当前Thread的实例 System.out.println(this.getName()); } }; t.start(); }}
线程的休眠
其实线程休眠就是调用Thread.sleep()方法。
回顾之前的学习内容，我们知道我们使用PCB描述一个进程，使用双向链表来组织进程。这种说法是针对一个进程中只有一个线程的情况下。
那么如果一个进程中有多个线程存在，那么每个线程就有一个PCB,那么每个进程都会有一组PCB,
PCB上有一个字段为tgroupId，这个id就相当于是进程的id,进程中的每个线程的tgroupId都是相同的。
那么进程控制块(process contral block)和线程有什么关系呢？
其实在linux中是不区分进程和线程的，所谓的线程是程序员自己搞出来的，实际上linux只认进程控制块(PCB),实际上线程就相当于一个轻量级进程。
到此这篇关于Java中Thread类的使用和它的属性的文章就介绍到这了,更多相关Java Thread类使用和属性内容请搜索盛行IT以前的文章或继续浏览下面的相关文章希望大家以后多多支持盛行IT！
郑重声明：本文由网友发布，不代表盛行IT的观点，版权归原作者所有，仅为传播更多信息之目的，如有侵权请联系，我们将第一时间修改或删除，多谢。