精华内容
下载资源
问答
  • 获取线程ID- getId 获取设置线程的名字 线程对象是否处于活动状态 - isAlive 获取当前线程的对象 休眠线程-sleep 加入线程-join 让出线程-yield 设置线程优先级 中断线程-Interrupt 守护线程-Deamon wait()...

    线程相关实例方法

    获取线程ID- getId

    • 在一个Java应用程序中,有一个long型的全局唯一的线程ID生成器threadSeqNumber,每new出来一个线程就会自增一次,从0开始,并且赋值给线程的tid属性。
    • 用户只能获取ID,不能执行一个线程的ID,这是Thread类内部自己完成的。

    获取和设置线程的名字

    • 获取线程名

      • 通过getName()方法获取线程对象名
      new Thread(){
          @Override
          public void run() {
              System.out.println(this.getName());//Thread-0
          }
      }.start();
    • 设置线程名

      • 通过构造函数传入String类型名
      new Thread("线程1"){
          @Override
          public void run() {
              System.out.println(this.getName());//线程1
          }
      }.start();
      
      new Thread("线程2"){
          @Override
          public void run() {
              System.out.println(this.getName());//线程2
          }
      }.start();
      
      //Lambda表达式的Runnable方式,Thread的构造函数
      Thread  t2 = new Thread(() ->
                              System.out.println("线程5的执行方法体"),"线程5");
      t2.start();
      System.out.println(t2.getName());//线程5
      • 通过setName(String name)方法设置
      new Thread(){
          @Override
          public void run() {
              this.setName("线程3");
              System.out.println(this.getName());//线程3
          }
      }.start();
      Thread t1 = new Thread() {
          @Override
          public void run() {
              System.out.println(this.getName());//线程4
          }
      };
      t1.setName("线程4");
      t1.start();
      Thread t1 = new Thread(()-> System.out.println("线程4的执行方法体"));
      t1.setName("线程4");
      t1.start();
      System.out.println(t1.getName());//线程4
      /*
              线程4
              线程4的执行方法体
        */

    线程对象是否处于活动状态 - isAlive

    • t.isAlive() 测试线程t是否处于活动状态,只要线程启动并且没有终止,方法返回值就是true
    • start()之前,线程不处于活动状态,之后就处于了活动状态。

    获取当前线程的对象

    • Thread.currentThread() 静态方法,获取当前执行线程, 主线程也可以获取

      //Runnable接口方式
      //new Thread(Runnable target,String threadName) 构造方法
      new Thread(()-> System.out.println(Thread.currentThread().getName()),"线程6")
                    .start();//线程6

      在main方法中可以获取主线程对象并设置:

      Thread.currentThread().setName("我是主线程");
      System.out.println(Thread.currentThread().getName());//我是主线程

    休眠线程-sleep

    • Thread.sleep(毫秒) / Thread.sleep(毫秒,纳秒) 控制当前线程休眠若干毫秒

      • 1秒 = 1000毫秒
      • 1秒 = 1000 * 1000 * 1000 纳秒 (100,000,000)
      new Thread(()->{
        for(int i = 0; i < 10 ;i++){
            System.out.println(Thread.currentThread().getName());
            try{
                Thread.sleep(1000); //每个线程休眠1秒(1000毫秒)
            }catch(InterruptedException e){
                e.printStackTrace();
            }
        }
      },"测试线程1").start();
    • sleep方法不会释放锁,wait方法会释放锁

    加入线程-join

    • join() 当前线程暂停,等待指定的线程执行结束后,当前线程才能再继续。即把指定的线程插队处理。
    • join(int ms) 可以等待指定的毫秒后再继续。
    • join()方法会使调用该方法的线程处于运行状态,让一开始所在的线程处于无限阻塞状态,直到调用了join方法的线程执行完毕,线程销毁为止。
    • 下面这个例子中,t2线程处于了阻塞状态,直到t1线程的run()方法执行完,线程死亡状态,t2线程才可以运行。
    public static void main(String[] args) {
        //Java8中 匿名内部类调用外接方法和变量时,外接变量可以不用final修饰,但是其值还是不能改变
        Thread t1 = new Thread() { //此时的t1在Java8之前必须用final修饰,是不可变的
            @Override
            public void run() {
                for (int i = 0; i < 10; i++) {
                    System.out.println(Thread.currentThread().getName() + "aaa");
                }
            }
        };
    
        Thread t2 = new Thread() {
            @Override
            public void run() {
                for (int i = 0; i < 10; i++) {
                    if (i == 2) {
                        try {
                            //Java8中 匿名内部类调用外接方法和变量时,外接变量可以不用final修饰,但是其值还是不能改变
                            t1.join();//t1线程对象来插队了,t1执行完之后t2才能继续执行
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                    System.out.println(Thread.currentThread().getName() + "bbb");
                }
            }
        };
        t1.start();
        t2.start();
    }

    执行结果:

    Thread-1bbb
    Thread-1bbb
    Thread-0aaa
    Thread-0aaa
    Thread-0aaa
    Thread-0aaa
    Thread-0aaa
    Thread-0aaa
    Thread-0aaa
    Thread-0aaa
    Thread-0aaa
    Thread-0aaa
    Thread-1bbb
    Thread-1bbb
    Thread-1bbb
    Thread-1bbb
    Thread-1bbb
    Thread-1bbb
    Thread-1bbb
    Thread-1bbb

    结果显示:当t2线程执行两个后,t1使用join方法来插队,t1执行完之后,t2才继续执行完。

    让出线程-yield

    • Thread.yield() 使该线程让出cpu,给其他线程使用cpu执行
    • yield只会把时间片让给同优先级的线程
    • 使CPU调度到其他线程,让该线程从运行状态回到可运行状态

    设置线程优先级

    • thread.setPriority(int priority) 设置线程的优先级

      • Thread类源码中有三种优先级:(1,5,10)
      /**
           * The minimum priority that a thread can have.
           */
      public final static int MIN_PRIORITY = 1;
      
      /**
           * The default priority that is assigned to a thread.
           */
      public final static int NORM_PRIORITY = 5;
      
      /**
           * The maximum priority that a thread can have.
           */
      public final static int MAX_PRIORITY = 10;
      • 优先级值:默认为5,最大为10,最小为1;

      • 不能超过1~10这个范围。

      t1.setPriority(Thread.MIN_PRIORITY);//最小
      t1.setPriority(Thread.MAX_PRIORITY);//最大

    中断线程-Interrupt

    • 中断可以理解为线程的一个标志位,它表示了一个运行中的线程是否被其他线程进行了中断操作
    • 其他线程可以调用该线程的interrupt()方法对其进行中断操作,同时该线程可以调用isInterrupted()来感知其他线程对其是否进行了中断操作,从而做出相应。
    • 也可以调用Thread中的静态方法interrupted()对当前线程进行中断操作,该方法会清除中断标志位
    • 当抛出InterruptedException时,会清除中断标志位,也就是说在调用isInterrupted会返回false。
    • 如果线程调用了 wait()、sleep()、join()方法而导致的阻塞,可以中断线程,并抛出InterruptedException来唤醒
    方法名 作用 备注
    public void interrupt() 中断该线程对象 如果线程调用了 wait()、sleep()、join()方法而导致的阻塞,可以中断线程,并抛出InterruptedException来唤醒,并且中断标志位会被清除
    public boolean isInterrupted() 测试该线程对象是否被中断 中断标志位不会被清除
    public static boolean interrupted() 测试当前线程是否被中断 中断标志位会被清除

    守护线程-Deamon

    • setDaemon(boolean on) 设置一个线程作为守护线程

    • 守护线程为其他线程的运行提供便利的服务,最典型的应用便是GC线程 。

    • 该线程不会单独执行,当其他非守护线程都执行结束后,守护线程就没有可服务的对象了,就会自动退出

      public static void main(String[] args) {
        Thread t1 = new Thread(()->{
            for (int i = 0; i < 3; i++) {
                System.out.println(Thread.currentThread().getName()+"非守护线程");
            }
        });
      
        Thread t2 = new Thread(()->{
            for (int i = 0; i < 30; i++) {
                System.out.println(Thread.currentThread().getName()+"守护线程");
            }
        });
      
        t2.setDaemon(true);//将t2设置成守护线程
        t1.start();
        t2.start();
      
      }
      • 第一次执行结果:
      Thread-0非守护线程
      Thread-0非守护线程
      Thread-0非守护线程
      
      • 说明:非守护线程直接执行完毕后,守护线程还未开启执行,就自动退出了。

      • 第二次执行结果:

      Thread-0非守护线程
      Thread-1守护线程
      Thread-1守护线程
      Thread-0非守护线程
      Thread-0非守护线程
      Thread-1守护线程
      Thread-1守护线程
      Thread-1守护线程
      Thread-1守护线程
      Thread-1守护线程
      • 根据结果发现,守护线程和非守护线程穿插执行,非守护线程执行完之后,守护线程继续执行了,没有立即停止,该现象为线程缓冲,即守护线程正在执行,需要等到非守护线程的执行完毕信号后,才能停止下来,自动退出。

    wait()和notify()/notifyAll()

    Object类中的wait()、notify()、notifyAll()三个方法,每个对象都是有的,结合多线程后可以起到很大的效果。

    wait()

    • wait()方法作用是使当前执行的代码的线程进行等待,当前线程会进入等待队列中。
    • wait()代码处会停止执行,直到接到通知(notify())或者被中断(Interrupt())。
    • 调用wait()之前线程必须获取该对象的锁,因此wait()方法只能在同步代码中调用执行。
    • wait()方法可以使调用该线程的方法释放共享资源的锁,然后从运行状态退出,进入等待队列,直到再次被唤醒。

    notify()

    • 唤醒等待的线程,如果有多个线程在等待队列中,那么会随机挑选一个等待的线程,对其发出唤醒通知,并且使它等待获取该对象的对象锁
    • 等待获取对象锁说明了即使收到了通知,wait 的线程也不会马上获取对象锁,会在锁池中进行等待notify方法的线程释放锁才可以,获取了对象锁之后才能从锁池中出去进入可运行状态
    • 在调用notify()之前,和wait()一样,必须在同步代码中调用。因为有锁的操作。
    • notify()不释放锁

    notifyAll()

    • notifyAll()方法可以使所有正在等待队列中等待同一共享资源的全部线程从等待状态退出,随机进入锁池,等待拿到对象锁,进入可运行状态。

    如果wait()方法和notify()/notifyAll()方法不在同步方法/同步代码块中被调用,那么虚拟机会抛出java.lang.IllegalMonitorStateException

    ☆ sleep()和wait()的区别

    1. 方法本质上:

      • wait()方法时Object类中的实例方法
      • 而sleep()方法时Thread类中的静态方法
    2. 使用环境上:

      • wait()方法必须要在同步方法或同步代码块中使用,因为它必须已经获得对象锁。
      • sleep()方法没有这个限制,它可以在任何地方使用。
    3. 是否释放锁:

      • wait()方法会释放占有的对象锁,使该线程进入等待池中。
      • sleep()方法不会释放对象锁,只会让出CPU
    4. 使其继续执行方式上:

      • wait()方法必须等待 notify()/notifyAll()方法的唤醒通知后,才会离开等待池并且如果再次获得CPU时间片才会继续执行。

      • sleep()方法在休眠时间到达后,如果再次获得CPU时间片就会继续执行。

    Java中用到的线程调度算法

    • Java中用到的是抢占式的线程调度算法。一个线程用完CPU后,操作系统会根据线程优先级、线程饥饿程度等数据算出一个总的优先级并分配下一个时间片给某个线程。

    Thread.sleep(0)的作用?

    • 平衡CPU控制权的一种操作:
      • 由于Java采用的是抢占式线程调度算法,因此可能就会出现某条线程综合来看常常会获取到CPU的控制权的情况,为了让某些优先级较低的线程也能获得到CPU控制权,可以使用Thread.sleep(0)手动出发一次操作系统分配时间片的操作,来平衡控制权。

    线程六大状态

    根据Thread类中定义的枚举类型State值,可以看出有6中状态:

        public enum State {
            NEW,
            RUNNABLE,
            WAITING,
            TIMED_WAITING,
            TERMINATED;
        }
    1. 新建状态 NEW

      新建了Thread类对象,但是没有启动的线程。new Thread()

    2. 可运行状态 RUNNABLE

      线程对象新建后,调用start()方法即处于了RUNNABLE状态。

      • 此状态线程可能在Java虚拟机中运行;
      • 可能在等待CPU处理器分配资源。
      • 一个线程只有获取到CPU的资源后,才可以运行其run()方法执行代码,否则就会处于排队等待
    3. 阻塞状态 BLOCKED

      该线程正在等待同步锁来进入一个同步代码块中来使用CPU资源,此时该线程就处于阻塞状态。

    4. 等待状态 WAITING

      线程调用以下方法时,会自己进入等待状态:

      • 不带超时的Object类中的wait()方法
      • 不带超时的Thread类中的join()方法
      • LockSupport类中的park()方法

      一直等待,直到手动唤醒

    5. 超时等待状态 TIMED_WAITING

      线程调用带有正的等待时间参数的下列各方法时,会处于超时等待状态:

      • Object中的wait()
      • Thread中的join()
      • Thread中的sleep()
      • LockSupport中的parkNanos()
      • LockSupport中的parkUntil()
    6. 终止状态 TERMINATED

      • 线程执行完毕,或run()方法全部执行结束后,线程进入终止状态。
      • 终止状态的线程不具备继续运行的能力。

    线程状态图

    线程状态图

    • 锁池队列:当资源被一个线程访问时,上锁后,其他线程就会进入锁池队列,当锁释放后,其他线程获得了锁,就会变成可运行状态。
    • 《Thinking in Java》中线程被阻塞的五种可能原因:
      1. 线程调用 sleep(ms) ,使线程睡眠,规定时间内,该线程不会运行。
      2. 使用suspend()暂停了线程的执行,除非收到resume()消息,否则不会进入可运行状态
      3. 线程正在等待一些IO操作完成
      4. 线程试图调用另一个对象的同步方法,但那个对象处于锁状态,暂时无法使用
      5. 调用wait()暂停了线程的执行,进入了等待队列。

    怎么唤醒一个阻塞的线程

    • 如果线程调用了 wait()、sleep()、join()方法而导致的阻塞,可以中断线程,并抛出InterruptedException来唤醒
    • 如果该线程遇到了IO阻塞,只能等系统IO操作结束后,才能唤醒,Java代码无能为力,无法直接接触到底层操作系统的调度。

    怎么检测一个线程是否持有对象监视器

    • Thread类提供了一个holdsLock(Object obj)方法,当且仅当对象obj的监视器被某条线程持有的时候才会返回true
    public static boolean holdsLock(Object obj)
    展开全文
  • 乘法表运算显示在控制台上,每个线程状态改变记录在log.txt中。 代码如下: package sec01; import java.io.FileWriter; import java.io....//线程信息的获取和设置 public class Calculator2 implements R

    乘法表运算显示在控制台上,每个线程的状态改变记录在log.txt中。

    代码如下:

    package sec01;
    
    import java.io.FileWriter;
    import java.io.IOException;
    import java.io.PrintWriter;
    
    //线程信息的获取和设置
    public class Calculator2 implements Runnable {  
        private int number;  
        public Calculator2(int number){  
            this.number = number;  
        }  
          
      //编写writeThreadInfo()方法,用于写下线程的ID、名称、优先级、旧状态和新状态
        private static void writeThreadInfo(PrintWriter pw, Thread thread,Thread.State state){
        	pw.write("Main : Id "+thread.getId()+" - "+thread.getName()+"\n");
        	pw.write("Main : Priority: "+thread.getPriority()+"\n");
        	pw.write("Main : Old State: "+state+"\n");
        	pw.write("Main : New State: "+thread.getState()+"\n");
        	pw.write("Main : ***************************\n");    	
        }
        
        @Override  
        public void run() {  
            // TODO Auto-generated method stub  
            for(int i =1; i<=10;i++){  //循环与number相乘并打印
                System.out.printf("%s: %d * %d = %d\n", Thread.currentThread().getName(),number,i,i*number);  
            }  
        }  
          
        public static void main(String[] args) {  
            // TODO Auto-generated method stub  
            Thread threads[] = new Thread[10]; //存放线程对象
            Thread.State status[] = new Thread.State[10]; //存放线程运行状态
            
            for(int i=0; i<10; i++){
            	threads[i] = new Thread(new Calculator2(i));     //创建线程对象
            	if(i%2==0){
            		threads[i].setPriority(Thread.MAX_PRIORITY);  //设置线程为最高优先级
            	}else {
            		threads[i].setPriority(Thread.MIN_PRIORITY);  //设置线程为最低优先级 
            	}
            	threads[i].setName("thread"+i); //设置线程名
            }
            
           //创建用于写入线程状态记录文件的对象
            try {
    			PrintWriter printWriter = new PrintWriter(".\\sec01\\log.txt");//记录文件路径
    			
    			for(int i=0; i<10; i++){
    				status[i] = threads[i].getState();
    				printWriter.write("Main : status of Thread "+" : "+i+ " : "+status[i]+"\n");
    			}
    			
    			//开始执行10个线程
    	        for(int i=0; i<10; i++){
    	        	threads[i].start();
    	        }
    	        
    	        boolean finish=false;
    	        while(!finish){
    	        	for(int i=0; i<10; i++){
    	        		if(threads[i].getState() != status[i]){
    	        			writeThreadInfo(printWriter, threads[i], status[i]);
    	        			status[i] = threads[i].getState();
    	        		}
    	        	}
    	        	
    	        	finish=true;
    	        	for(int i=0; i<10; i++){//直到10个线程均执行完毕,finish才为true
    	        		finish = finish && (threads[i].getState()==Thread.State.TERMINATED); //若线程执行结束,则finish置为true
    	        	}
    	        }
    	        
    	        printWriter.flush();
    	        printWriter.close();
    		} catch (IOException e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		}
            
        }  
      
    }  
    


    结果:

    控制台
    thread4: 4 * 1 = 4
    thread5: 5 * 1 = 5
    thread5: 5 * 2 = 10
    thread5: 5 * 3 = 15
    thread5: 5 * 4 = 20
    thread5: 5 * 5 = 25
    thread5: 5 * 6 = 30
    thread5: 5 * 7 = 35
    thread5: 5 * 8 = 40
    thread5: 5 * 9 = 45
    thread5: 5 * 10 = 50
    thread9: 9 * 1 = 9
    thread9: 9 * 2 = 18
    thread9: 9 * 3 = 27
    thread7: 7 * 1 = 7
    thread7: 7 * 2 = 14
    thread7: 7 * 3 = 21
    thread7: 7 * 4 = 28
    thread7: 7 * 5 = 35
    thread7: 7 * 6 = 42
    thread7: 7 * 7 = 49
    thread7: 7 * 8 = 56
    thread7: 7 * 9 = 63
    thread7: 7 * 10 = 70
    thread3: 3 * 1 = 3
    thread3: 3 * 2 = 6
    thread3: 3 * 3 = 9
    thread3: 3 * 4 = 12
    thread3: 3 * 5 = 15
    thread3: 3 * 6 = 18
    thread3: 3 * 7 = 21
    thread3: 3 * 8 = 24
    thread3: 3 * 9 = 27
    thread3: 3 * 10 = 30
    thread1: 1 * 1 = 1
    thread8: 8 * 1 = 8
    thread6: 6 * 1 = 6
    thread0: 0 * 1 = 0
    thread2: 2 * 1 = 2
    thread0: 0 * 2 = 0
    thread6: 6 * 2 = 12
    thread6: 6 * 3 = 18
    thread8: 8 * 2 = 16
    thread8: 8 * 3 = 24
    thread8: 8 * 4 = 32
    thread8: 8 * 5 = 40
    thread8: 8 * 6 = 48
    thread8: 8 * 7 = 56
    thread8: 8 * 8 = 64
    thread8: 8 * 9 = 72
    thread8: 8 * 10 = 80
    thread1: 1 * 2 = 2
    thread1: 1 * 3 = 3
    thread1: 1 * 4 = 4
    thread1: 1 * 5 = 5
    thread1: 1 * 6 = 6
    thread1: 1 * 7 = 7
    thread1: 1 * 8 = 8
    thread1: 1 * 9 = 9
    thread1: 1 * 10 = 10
    thread9: 9 * 4 = 36
    thread4: 4 * 2 = 8
    thread4: 4 * 3 = 12
    thread4: 4 * 4 = 16
    thread4: 4 * 5 = 20
    thread4: 4 * 6 = 24
    thread4: 4 * 7 = 28
    thread4: 4 * 8 = 32
    thread4: 4 * 9 = 36
    thread4: 4 * 10 = 40
    thread9: 9 * 5 = 45
    thread6: 6 * 4 = 24
    thread0: 0 * 3 = 0
    thread2: 2 * 2 = 4
    thread0: 0 * 4 = 0
    thread6: 6 * 5 = 30
    thread0: 0 * 5 = 0
    thread0: 0 * 6 = 0
    thread0: 0 * 7 = 0
    thread0: 0 * 8 = 0
    thread0: 0 * 9 = 0
    thread0: 0 * 10 = 0
    thread9: 9 * 6 = 54
    thread2: 2 * 3 = 6
    thread2: 2 * 4 = 8
    thread2: 2 * 5 = 10
    thread2: 2 * 6 = 12
    thread2: 2 * 7 = 14
    thread2: 2 * 8 = 16
    thread2: 2 * 9 = 18
    thread2: 2 * 10 = 20
    thread9: 9 * 7 = 63
    thread6: 6 * 6 = 36
    thread6: 6 * 7 = 42
    thread6: 6 * 8 = 48
    thread6: 6 * 9 = 54
    thread6: 6 * 10 = 60
    thread9: 9 * 8 = 72
    thread9: 9 * 9 = 81
    thread9: 9 * 10 = 90
    

    log.txt:

    Main : status of Thread  : 0 : NEW
    Main : status of Thread  : 1 : NEW
    Main : status of Thread  : 2 : NEW
    Main : status of Thread  : 3 : NEW
    Main : status of Thread  : 4 : NEW
    Main : status of Thread  : 5 : NEW
    Main : status of Thread  : 6 : NEW
    Main : status of Thread  : 7 : NEW
    Main : status of Thread  : 8 : NEW
    Main : status of Thread  : 9 : NEW
    Main : Id 10 - thread0
    Main : Priority: 10
    Main : Old State: NEW
    Main : New State: BLOCKED
    Main : ***************************
    Main : Id 11 - thread1
    Main : Priority: 1
    Main : Old State: NEW
    Main : New State: RUNNABLE
    Main : ***************************
    Main : Id 12 - thread2
    Main : Priority: 10
    Main : Old State: NEW
    Main : New State: BLOCKED
    Main : ***************************
    Main : Id 13 - thread3
    Main : Priority: 1
    Main : Old State: NEW
    Main : New State: RUNNABLE
    Main : ***************************
    Main : Id 14 - thread4
    Main : Priority: 10
    Main : Old State: NEW
    Main : New State: RUNNABLE
    Main : ***************************
    Main : Id 15 - thread5
    Main : Priority: 1
    Main : Old State: NEW
    Main : New State: RUNNABLE
    Main : ***************************
    Main : Id 16 - thread6
    Main : Priority: 10
    Main : Old State: NEW
    Main : New State: BLOCKED
    Main : ***************************
    Main : Id 17 - thread7
    Main : Priority: 1
    Main : Old State: NEW
    Main : New State: RUNNABLE
    Main : ***************************
    Main : Id 18 - thread8
    Main : Priority: 10
    Main : Old State: NEW
    Main : New State: BLOCKED
    Main : ***************************
    Main : Id 19 - thread9
    Main : Priority: 1
    Main : Old State: NEW
    Main : New State: RUNNABLE
    Main : ***************************
    Main : Id 11 - thread1
    Main : Priority: 1
    Main : Old State: RUNNABLE
    Main : New State: BLOCKED
    Main : ***************************
    Main : Id 13 - thread3
    Main : Priority: 1
    Main : Old State: RUNNABLE
    Main : New State: BLOCKED
    Main : ***************************
    Main : Id 17 - thread7
    Main : Priority: 1
    Main : Old State: RUNNABLE
    Main : New State: BLOCKED
    Main : ***************************
    Main : Id 19 - thread9
    Main : Priority: 1
    Main : Old State: RUNNABLE
    Main : New State: BLOCKED
    Main : ***************************
    Main : Id 15 - thread5
    Main : Priority: 1
    Main : Old State: RUNNABLE
    Main : New State: BLOCKED
    Main : ***************************
    Main : Id 15 - thread5
    Main : Priority: 1
    Main : Old State: BLOCKED
    Main : New State: RUNNABLE
    Main : ***************************
    Main : Id 14 - thread4
    Main : Priority: 10
    Main : Old State: RUNNABLE
    Main : New State: BLOCKED
    Main : ***************************
    Main : Id 19 - thread9
    Main : Priority: 1
    Main : Old State: BLOCKED
    Main : New State: RUNNABLE
    Main : ***************************
    Main : Id 15 - thread5
    Main : Priority: 1
    Main : Old State: RUNNABLE
    Main : New State: TERMINATED
    Main : ***************************
    Main : Id 17 - thread7
    Main : Priority: 1
    Main : Old State: BLOCKED
    Main : New State: RUNNABLE
    Main : ***************************
    Main : Id 19 - thread9
    Main : Priority: 1
    Main : Old State: RUNNABLE
    Main : New State: BLOCKED
    Main : ***************************
    Main : Id 17 - thread7
    Main : Priority: 1
    Main : Old State: RUNNABLE
    Main : New State: TERMINATED
    Main : ***************************
    Main : Id 13 - thread3
    Main : Priority: 1
    Main : Old State: BLOCKED
    Main : New State: RUNNABLE
    Main : ***************************
    Main : Id 11 - thread1
    Main : Priority: 1
    Main : Old State: BLOCKED
    Main : New State: RUNNABLE
    Main : ***************************
    Main : Id 18 - thread8
    Main : Priority: 10
    Main : Old State: BLOCKED
    Main : New State: RUNNABLE
    Main : ***************************
    Main : Id 11 - thread1
    Main : Priority: 1
    Main : Old State: RUNNABLE
    Main : New State: BLOCKED
    Main : ***************************
    Main : Id 13 - thread3
    Main : Priority: 1
    Main : Old State: RUNNABLE
    Main : New State: TERMINATED
    Main : ***************************
    Main : Id 16 - thread6
    Main : Priority: 10
    Main : Old State: BLOCKED
    Main : New State: RUNNABLE
    Main : ***************************
    Main : Id 18 - thread8
    Main : Priority: 10
    Main : Old State: RUNNABLE
    Main : New State: BLOCKED
    Main : ***************************
    Main : Id 10 - thread0
    Main : Priority: 10
    Main : Old State: BLOCKED
    Main : New State: RUNNABLE
    Main : ***************************
    Main : Id 16 - thread6
    Main : Priority: 10
    Main : Old State: RUNNABLE
    Main : New State: BLOCKED
    Main : ***************************
    Main : Id 10 - thread0
    Main : Priority: 10
    Main : Old State: RUNNABLE
    Main : New State: BLOCKED
    Main : ***************************
    Main : Id 12 - thread2
    Main : Priority: 10
    Main : Old State: BLOCKED
    Main : New State: RUNNABLE
    Main : ***************************
    Main : Id 10 - thread0
    Main : Priority: 10
    Main : Old State: BLOCKED
    Main : New State: RUNNABLE
    Main : ***************************
    Main : Id 12 - thread2
    Main : Priority: 10
    Main : Old State: RUNNABLE
    Main : New State: BLOCKED
    Main : ***************************
    Main : Id 10 - thread0
    Main : Priority: 10
    Main : Old State: RUNNABLE
    Main : New State: BLOCKED
    Main : ***************************
    Main : Id 16 - thread6
    Main : Priority: 10
    Main : Old State: BLOCKED
    Main : New State: RUNNABLE
    Main : ***************************
    Main : Id 18 - thread8
    Main : Priority: 10
    Main : Old State: BLOCKED
    Main : New State: RUNNABLE
    Main : ***************************
    Main : Id 16 - thread6
    Main : Priority: 10
    Main : Old State: RUNNABLE
    Main : New State: BLOCKED
    Main : ***************************
    Main : Id 18 - thread8
    Main : Priority: 10
    Main : Old State: RUNNABLE
    Main : New State: TERMINATED
    Main : ***************************
    Main : Id 11 - thread1
    Main : Priority: 1
    Main : Old State: BLOCKED
    Main : New State: RUNNABLE
    Main : ***************************
    Main : Id 11 - thread1
    Main : Priority: 1
    Main : Old State: RUNNABLE
    Main : New State: TERMINATED
    Main : ***************************
    Main : Id 19 - thread9
    Main : Priority: 1
    Main : Old State: BLOCKED
    Main : New State: RUNNABLE
    Main : ***************************
    Main : Id 14 - thread4
    Main : Priority: 10
    Main : Old State: BLOCKED
    Main : New State: RUNNABLE
    Main : ***************************
    Main : Id 19 - thread9
    Main : Priority: 1
    Main : Old State: RUNNABLE
    Main : New State: BLOCKED
    Main : ***************************
    Main : Id 14 - thread4
    Main : Priority: 10
    Main : Old State: RUNNABLE
    Main : New State: TERMINATED
    Main : ***************************
    Main : Id 19 - thread9
    Main : Priority: 1
    Main : Old State: BLOCKED
    Main : New State: RUNNABLE
    Main : ***************************
    Main : Id 16 - thread6
    Main : Priority: 10
    Main : Old State: BLOCKED
    Main : New State: RUNNABLE
    Main : ***************************
    Main : Id 16 - thread6
    Main : Priority: 10
    Main : Old State: RUNNABLE
    Main : New State: BLOCKED
    Main : ***************************
    Main : Id 10 - thread0
    Main : Priority: 10
    Main : Old State: BLOCKED
    Main : New State: RUNNABLE
    Main : ***************************
    Main : Id 12 - thread2
    Main : Priority: 10
    Main : Old State: BLOCKED
    Main : New State: RUNNABLE
    Main : ***************************
    Main : Id 10 - thread0
    Main : Priority: 10
    Main : Old State: RUNNABLE
    Main : New State: BLOCKED
    Main : ***************************
    Main : Id 10 - thread0
    Main : Priority: 10
    Main : Old State: BLOCKED
    Main : New State: RUNNABLE
    Main : ***************************
    Main : Id 12 - thread2
    Main : Priority: 10
    Main : Old State: RUNNABLE
    Main : New State: BLOCKED
    Main : ***************************
    Main : Id 19 - thread9
    Main : Priority: 1
    Main : Old State: RUNNABLE
    Main : New State: BLOCKED
    Main : ***************************
    Main : Id 16 - thread6
    Main : Priority: 10
    Main : Old State: BLOCKED
    Main : New State: RUNNABLE
    Main : ***************************
    Main : Id 10 - thread0
    Main : Priority: 10
    Main : Old State: RUNNABLE
    Main : New State: BLOCKED
    Main : ***************************
    Main : Id 16 - thread6
    Main : Priority: 10
    Main : Old State: RUNNABLE
    Main : New State: BLOCKED
    Main : ***************************
    Main : Id 10 - thread0
    Main : Priority: 10
    Main : Old State: BLOCKED
    Main : New State: RUNNABLE
    Main : ***************************
    Main : Id 10 - thread0
    Main : Priority: 10
    Main : Old State: RUNNABLE
    Main : New State: TERMINATED
    Main : ***************************
    Main : Id 19 - thread9
    Main : Priority: 1
    Main : Old State: BLOCKED
    Main : New State: RUNNABLE
    Main : ***************************
    Main : Id 12 - thread2
    Main : Priority: 10
    Main : Old State: BLOCKED
    Main : New State: RUNNABLE
    Main : ***************************
    Main : Id 19 - thread9
    Main : Priority: 1
    Main : Old State: RUNNABLE
    Main : New State: BLOCKED
    Main : ***************************
    Main : Id 12 - thread2
    Main : Priority: 10
    Main : Old State: RUNNABLE
    Main : New State: TERMINATED
    Main : ***************************
    Main : Id 19 - thread9
    Main : Priority: 1
    Main : Old State: BLOCKED
    Main : New State: RUNNABLE
    Main : ***************************
    Main : Id 16 - thread6
    Main : Priority: 10
    Main : Old State: BLOCKED
    Main : New State: RUNNABLE
    Main : ***************************
    Main : Id 19 - thread9
    Main : Priority: 1
    Main : Old State: RUNNABLE
    Main : New State: BLOCKED
    Main : ***************************
    Main : Id 16 - thread6
    Main : Priority: 10
    Main : Old State: RUNNABLE
    Main : New State: TERMINATED
    Main : ***************************
    Main : Id 19 - thread9
    Main : Priority: 1
    Main : Old State: BLOCKED
    Main : New State: RUNNABLE
    Main : ***************************
    Main : Id 19 - thread9
    Main : Priority: 1
    Main : Old State: RUNNABLE
    Main : New State: TERMINATED
    Main : ***************************
    



    
    
    展开全文
  • ID: 每个线程的独特标识。 Name: 线程的名称。 Priority: 线程对象的优先级。优先级别在1-10之间,1是最低级,10是最高级。不建议改变它们的优先级,但是你想的话也是可以的。 Status: 线程状态。在Java中,...

    Thread类的对象中保存了一些属性信息能够帮助我们来辨别每一个线程,知道它的状态,调整控制其优先级。 这些属性是:

    • ID: 每个线程的独特标识。
    • Name: 线程的名称。
    • Priority: 线程对象的优先级。优先级别在1-10之间,1是最低级,10是最高级。不建议改变它们的优先级,但是你想的话也是可以的。
    • Status: 线程的状态。在Java中,线程只能有这6种中的一种状态: new, runnable, blocked, waiting, time waiting, 或 terminated

     

    Thread  threads[] = new Thread[10];
    
            Thread.State states[] = new Thread.State[10];
            PrintWriter pw = null;
            for(int i = 1 ; i < 10 ; i++){
              threads[i] = new Thread(new Caculator(i));
              if(i%2 == 0){
                  threads[i].setPriority(Thread.MAX_PRIORITY);
              }else{
                  threads[i].setPriority(Thread.MIN_PRIORITY);
              }
              threads[i].setName("Thread"+i);
           }

     

    转载于:https://www.cnblogs.com/da-peng/p/8401733.html

    展开全文
  • Thread类包含几个属性,这些属性所表示的信息能帮助我们识别线程、观察其状态、控制其优先级等。这些线程包括如下几种: ID: 该属性表示每个线程的唯一标识; Name: 该属性存储每个线程的名称; Priority: 该...

    1、线程属性

    Thread类包含几个属性,这些属性所表示的信息能帮助我们识别线程、观察其状态、控制其优先级等。这些线程包括如下几种:

    ID: 该属性表示每个线程的唯一标识;
    Name: 该属性存储每个线程的名称;
    Priority: 该属性存储每个Thread对象的优先级。线程优先级分1到10十个级别,1表示最低优先级,10表示最高优先级。并不推荐修改线程的优先级,但是如果确实有这方面的需求,也可以尝试一下。
    Status: 该属性存储线程的状态。线程共有六种不同的状态:新建(NEW)、运行(RUNNABLE)、阻塞(BLOCKED)、等待(WAITING)、限时等待(TIMED_WAITING)或者终止(TERMINATED)。线程的状态必定是其中一种。

    2、代码实现

    本例子展现了使用线程运行乘法口诀,获取和设置线程属性。线程类如下:

    package com.xxx.util;
    
    /**
     * Created with IntelliJ IDEA.
     * Date: 15-3-25
     * Time: 上午8:40
     * To change this template use File | Settings | File Templates.
     */
    public class ThreadPrioritySet implements Runnable {
    
        private int num;
    
        public ThreadPrioritySet(int num){
            this.num = num;
        }
    
        @Override
        public void run() {
            for(int i=1;i<10;i++){
                System.out.printf("%s:%d*%d=%d\n",Thread.currentThread().getName(),num,i,i*num);
            }
        }
    }
    

    main类:

    package com.xxx.util;
    
    
    import java.io.*;
    import java.util.Date;
    
    
    /**
     * Created with IntelliJ IDEA.
     * Date: 15-3-25
     * Time: 上午8:47
     * To change this template use File | Settings | File Templates.
     */
    public class ThreadPrioritySetMain {
    
    
        public static void main(String[] args){
            long startTime = new Date().getTime();
            System.out.printf("*******************开始时间%d******************************\n",startTime);
            Thread threads[] = new Thread[10];
            Thread.State status[] = new Thread.State[10];
            for(int i=1;i<10;i++){
                threads[i] = new Thread(new ThreadPrioritySet(i));
                if((i%2)==0){
                    threads[i].setPriority(Thread.MAX_PRIORITY);
                }else {
                    threads[i].setPriority(Thread.MIN_PRIORITY);
                }
                threads[i].setName("Tread "+i);
            }
            PrintWriter printWriter = null;
            File file = null;
            try {
                //System.getProperty("user.dir")是取得当前项目的根目录;
                File filePath = new File(System.getProperty("user.dir")+"\\data\\");
                if(!filePath.exists()){
                    filePath.mkdirs();
                }
                file = new File(filePath+"\\threadPrioritySet.txt");
                if(!file.exists()){
                    file.createNewFile();
                }
                //可是第二个参数设置追加(true),默认不追加,即覆盖
                FileWriter fileWriter = new FileWriter(file);
                printWriter = new PrintWriter(fileWriter);
                //BufferedWriter 提供缓冲,用以加速
                //printWriter = new PrintWriter(new BufferedWriter(fileWriter));
                for(int i=1;i<10;i++){
                    printWriter.println("Main:Status of Thread "+i+":"+threads[i].getState());
                    status[i] = threads[i].getState();
                }
                //启动线程
                for(int i=1;i<10;i++){
                    threads[i].start();
                }
                boolean finish = false;
                while (!finish){
                    for(int i=1;i<10;i++){
                        if(threads[i].getState()!=status[i]){//判断线程状态是否发生变化
                            System.out.println("+++++++++++start+++++++++++++"+i);
                            writeThreadInfo(printWriter,threads[i],status[i]);
                            System.out.println("+++++++++++end+++++++++++++"+i);
                            status[i] = threads[i].getState();
                        }
                    }
                    finish = true;
                     //判断线程是否TERMINATED,直到线程都运行完成,任何一个线程的状态发生变化,就会将它写入文件中
                    for(int i=1;i<10;i++){
                        //赋值运算,获取线程状态,如果不是TERMINATED,finish=false再进行while循环
                        finish = finish&&(threads[i].getState()== Thread.State.TERMINATED);
                    }
                }
            } catch (IOException e) {
                e.printStackTrace();  //To change body of catch statement use File | Settings | File Templates.
            }finally {
                if(printWriter!=null){
                    printWriter.flush();
                    printWriter.close();//需要关闭才能写入
                    long endTime = new Date().getTime();
                    System.out.printf("*******************结束时间%d******************************\n",new Date().getTime());
                    System.out.printf("*******************耗时%d******************************\n", endTime - startTime);
                    //readThreadInfo(file);
                }
            }
        }
    
    
        private static int flagNum = 0;
        /**
         * 写入文件信息
         * @param printWriter
         * @param thread
         * @param state
         */
        private static void writeThreadInfo(PrintWriter printWriter,Thread thread,Thread.State state){
            System.out.println("+++++++++ing+++++++++++"+(++flagNum));
            printWriter.printf("*******************Name=%s****************************\n",thread.getName());
            printWriter.printf("Main:Id:%d - Name:%s\n",thread.getId(),thread.getName());
            printWriter.printf("Main:Priority:%d\n", thread.getPriority());
            printWriter.printf("Main:Old State:%s\n", state);
            printWriter.printf("Main:New State:%s\n", thread.getState());
            printWriter.printf("*******************Name=%s****************************\n\n",thread.getName());
        }
    
    
        /**
         * 读取文件输出控制台
         * @param file
         */
        private static void readThreadInfo(File file){
            String str= null;
            FileReader fileReader = null;
            BufferedReader bufferedReader = null;
            try {
                fileReader = new FileReader(file);
                bufferedReader = new BufferedReader(fileReader);
                while((str=bufferedReader.readLine())!=null){
                    System.out.printf("%s\n", str);
                }
            } catch (Exception e) {
                e.printStackTrace();  //To change body of catch statement use File | Settings | File Templates.
            }finally {
                if(bufferedReader!=null){
                    try {
                        bufferedReader.close();
                    } catch (IOException e) {
                        e.printStackTrace();  //To change body of catch statement use File | Settings | File Templates.
                    }
                }
                if(fileReader!=null){
                    try {
                        fileReader.close();
                    } catch (IOException e) {
                        e.printStackTrace();  //To change body of catch statement use File | Settings | File Templates.
                    }
                }
            }
        }
    
    
    }
    


    3、部分运行结果

    (1)控制台结果




    (2)文件结果



    4、结论

    高优先级的线程大致比低优先级的线程较早完成执行,只是大致。

    Thread类有可以存储线程信息所需的所有属性。Java虚拟机使用线程优先级来每个时刻调度一个线程来使用CPU,并且根据线程的情况来设置其每个线程的状态。

    展开全文
  • 常用线程属性ID: 每个线程的...Status: 线程状态,包含6种状态:new, runnable, blocked, waiting, time waiting, terminated本例中,我们会开发一个程序以设置线程名称优先级并展示一些线程信息。Calculator.java...
  • 一、守护线程非守护线程我们获取线程id的时候会发现每次都不是0,这是因为在java虚拟机运行一个线程的时候会默认启动一些其他的线程,来为我们的线程服务。默认创建的我们自己创建的线程是有区分的。这就要...
  • JAVA线程知识点

    2020-07-08 18:43:29
    获取线程ID和线程名称 Thread子类中调用this.getId()或者this.getName() 使用Thread.currentThread().getID()和Thread.currentThread().getName() 修改线程名称 调用线程对象的setName()方法 使用线程子类的构造...
  • Thread类的对象中保存了一些属性信息能够帮助我们辨别每一个线程,知道它的一些信息 ...Status:线程状态。在Java中,线程只有6种状态:new,runnable,blocked,waiting,time waiting或terminated。 ...
  • 我们获取线程id的时候会发现每次都不是0,这是因为在java虚拟机运行一个线程的时候会默认启动一些其他的线程,来为我们的线程服务。默认创建的我们自己创建的线程是有区分的。这就要区分守护线程非守护线程了...
  • 本节书摘来异步社区《Java 7并发编程实战手册》一书中...1.3 线程信息的获取和设置 Thread类有一些保存信息的属性,这些属性可以用来标识线程,显示线程状态或者控制线程的优先级。 ID:保存了线程的唯一标示符。...
  • 开门见山Thread类包含几个属性,这些属性所表示的信息能帮助我们识别线程、观察其状态、控制其优先级等。这些线程包括如下几种:ID: 该属性表示每个线程的唯一标识; Name: 该属性存储每个线程的名称; Priority...
  • 一、守护线程非守护线程我们获取线程id的时候会发现每次都不是0,这是因为在java虚拟机运行一个线程的时候会默认启动一些其他的线程,来为我们的线程服务。默认创建的我们自己创建的线程是有区分的。这就要...
  • 线程管理之获取和设置线程信息

    千次阅读 2015-08-02 00:41:35
    获取和设置线程信息 Thread类的对象中保存了一些属性信息能够帮助我们来辨别每一个线程,知道它的状态,调整控制其优先级。 这些属性是: ID: 每个线程的独特标识。Name: 线程的名称。Priority: 线程对象的优先级...
  • 一、守护线程非守护线程我们获取线程id的时候会发现每次都不是0,这是因为在java虚拟机运行一个线程的时候会默认启动一些其他的线程,来为我们的线程服务。默认创建的我们自己创建的线程是有区分的。这就要...
  • 一、守护线程非守护线程我们获取线程id的时候会发现每次都不是0,这是因为在java虚拟机运行一个线程的时候会默认启动一些其他的线程,来为我们的线程服务。默认创建的我们自己创建的线程是有区分的。这就要...
  • 在上一篇文章中对线程状态生命周期常见的线程api进行了一个讲解。这篇文章开始着重对其构造方法...我们获取线程id的时候会发现每次都不是0,这是因为在java虚拟机运行一个线程的时候会默认启动一些其他的线程,...
  • 一、守护线程非守护线程我们获取线程id的时候会发现每次都不是0,这是因为在java虚拟机运行一个线程的时候会默认启动一些其他的线程,来为我们的线程服务。默认创建的我们自己创建的线程是有区分的。这就要...
  • 前言由于Java高级并发编程主要是针对多线程并发访问公共资源控制来展开的,而现在服务器大多都是多核处理,所以在执行控制中,单一的同步锁无法满足需要,为此Java 1.5开始引入了三个重要的概念Semaphores,...
  • 获取线程ID。 getName(), setName() 获取设置线程名。 getPriority(), setPriority() 获取设置线程优先级。 getState() 获取线程状态。 getThreadGroup
  • 简介锁同步是java线程编程中非常常见的使用场景。为了锁定多线程共享的对象,Java需要提供一定的机制来实现共享对象的锁定,从而保证一次只有一个线程能够作用于共享对象。当第二个线程进入同一个区域的时候,...
  • 1. 线程的创建运行:在Java中,我们有2...获取和设置线程信息:Thread类的对象中保存了一些属性信息能够帮助我们来辨别每一个线程,知道它的状态,调整控制其优先级。 这些属性是:ID: 每个线程的独特标识。Name:...
  • Java并发学习】之详解线程的点滴2前言在前面一个小节中,我们学习了线程的属性如,ID、名字、优先级、状态获取以及设置(如果可以操作)以及守护线程的概念线程设置为守护线程的方法,接下来这个小节,我们来...
  • 利用线程获取json数据,肯定能获取到,获取到的json传给公有的json,可是每次公有的json里面都是空值,求大神给解决方案。 我的代码 package textview.exam; import android.app.AlertDialog; import android....
  • 一、Lock体系结构1、基础接口简介Lock加锁相关结构中涉及两个使用广泛的基础API:ReentrantLock类Condition接口,基本关系如下:Lock接口Java并发编程中资源加锁的根接口之一,规定了资源锁使用的几个基础方法。...
  • 条件队列是什么?可能很多人我一样答不出来,...在Java中的等待唤醒机制中我们提到了条件队列,即当对象获取到同步锁之后,如果调用了wait方法,当前线程会进入到条件队列中,并释放锁。synchronized(对象){ // ...
  • 锁的升级比较 无状态锁(01)–>偏心锁(10)–>轻量级锁(00)(自旋锁)...偏向锁的MarkWord中包含:线程ID、epoch、对象分代年龄、是否偏心锁(1)、锁标志位(01) 偏向锁的获得: 当锁对象第一次被获取时,如线程1访问同步快,

空空如也

空空如也

1 2 3 4 5
收藏数 93
精华内容 37
关键字:

java获取线程id和线程状态

java 订阅