JAVA进阶13

间歇性混吃等死，持续性踌躇满志系列-------------第13天

1、查看线程的运行状态

 package code0327;

 class Demo01 implements Runnable {
     public synchronized void waitForASecond() throws InterruptedException {
         wait(500); //使当前线程等待0.5秒或其他线程调用notify()或notifyAll()方法
     }

     public synchronized void waitForYears() throws InterruptedException {
         //使当前线程永久等待，直到其他线程调用notify()或notifyAll()方法
         wait();
     }

     public synchronized void notifyNow() throws InterruptedException {
         //唤醒由调用wait()方法进入等待状态的线程
         notify();
     }

     public void run() {
         try {
             //在线程中运行waitForASecond()方法
             waitForASecond();
             //在线程中运行waitForYears()方法
             waitForYears();
         } catch (InterruptedException e) {
             e.printStackTrace();
         }
     }
 }

 class Test {
     public static void main(String[] args) throws InterruptedException{
         //创建state对象
         Demo01  state = new Demo01();
         //利用state对象创建Thread对象
         Thread thread = new Thread(state);
         //输出线程状态
         System.out.println("新建线程："+thread.getState());
         //调用thread对象的start()方法，启动新线程
         thread.start();
         //输出线程状态
         System.out.println("启动线程："+thread.getState());
         //当前线程休眠0.1秒，使新线程运行waiForASecond()方法
         Thread.sleep(100);
         //输出线程状态
         System.out.println("计时等待："+thread.getState());
         //当前线程休眠1秒，使新线程运行waiForYears()方法
         Thread.sleep(1000);
         //输出线程状态
         System.out.println("等待线程："+thread.getState());
         //调用state的notifyNow()方法
         state.notifyNow();
         //输出线程状态
         System.out.println("唤醒线程："+thread.getState());
         //当前线程休眠1秒，使新线程结束
         Thread.sleep(1000);
         //输出线程状态
         System.out.println("终止线程："+thread.getState());
     }
 }

运行结果图

2、查看JVM的线程名

 package code0327;

 import java.util.ArrayList;
 import java.util.List;

 public class ThreadList {
     //获得根线程组
     private static ThreadGroup getRootThreadGroups() {
         //获得当前线程组
         ThreadGroup rootGroup = Thread.currentThread().getThreadGroup();
         while (true){
             //如果getParent()方法的返回值非空则不是根线程组
             if(rootGroup.getParent()!=null){
                 //获得父线程组
                 rootGroup = rootGroup.getParent();
             }else {
                 //如果到达根线程组则退出循环
                 break;
             }
         }
         //返回根线程组
         return rootGroup;
     }
     //获得线程组中所有的线程名
     public static List<String> getThreads(ThreadGroup group){
         //创建保存线程名的列表
         List<String> threadList = new ArrayList<String>();
         //根据活动线程数创建线程数组
         Thread[] threads = new Thread[group.activeCount()];
         //复制线程到线程数组
         int count = group.enumerate(threads,false);
         //遍历线程数组将线程名及其所在组保存到列表中
         for (int i = 0; i < count; i++) {
             threadList.add(group.getName()+"线程组："+threads[i].getName());
         }
         return threadList;
     }
     //获得线程组中子线程组
     public static List<String> getThreadGroups(ThreadGroup group){
         //获得给定线程组中线程名
         List<String> threadList = getThreads(group);
         //创建线程组数组
         ThreadGroup[] groups = new ThreadGroup[group.activeCount()];
         //复制子线程组到线程组数据
         int count = group.enumerate(groups,false);
         //遍历所有子线程组
         for (int i = 0; i < count; i++) {
             //利用getThreads()方法获得线程组名李彪
             threadList.addAll(getThreads(groups[i]));
         }
         //返回所有线程名
         return threadList;
     }

     public static void main(String[] args) {
         for(String string:getThreadGroups(getRootThreadGroups())){
             //遍历输出列表中的字符串
             System.out.println(string);
         }
     }
 }

运行结果图

3、线程的生命周期

 package code0327;

 import javax.swing.*;
 import java.awt.*;
 import java.util.Random;

 public class SleepMethodTest extends JFrame {
     private Thread t;
     //定义颜色数组
     private static Color[] color = {Color.BLACK, Color.YELLOW, Color.RED, Color.PINK, Color.LIGHT_GRAY};
     //创建随机对象
     private static final Random rand = new Random();

     //获取随机颜色值的方法
     private static Color getC() {
         return color[rand.nextInt(color.length)];
     }

     public SleepMethodTest() {
         //创建匿名线程对象
         t = new Thread(new Runnable() {
             //定义初始坐标
             int x = 350;
             int y = 450;

             //覆盖线程接口方法
             public void run() {
                 //无限循环
                 while (true) {
                     try {
                         //线程休眠0.1秒
                         t.sleep(100);
                     } catch (InterruptedException e) {
                         e.printStackTrace();
                     }
                     //获取组件绘图上下文对象
                     Graphics graphics = getGraphics();
                     //设置绘图颜色
                     graphics.setColor(getC());
                     //绘制直线并递增垂直坐标
                     graphics.drawLine(x, y, 100, y++);
                     if (y >= 80) {
                         y = 50;
                     }
                 }
             }
         });
         //启动线程
         t.start();
     }

     public static void main(String[] args) {
         init(new SleepMethodTest(),500,500);
     }
     //初始化程序界面方法
     public static void init(JFrame frame,int width,int height){
         frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
         frame.setSize(width,height);
         frame.setVisible(true);
     }
 }

运行结果图

4、static关键字

一旦用了static关键字，那么这样的内容不再属于对象自己，而是属于类的，所有凡是本类的对象，都共享同一份。

 package cn.intcast.demo13;

 public class Student {
     private String name;  //姓名
     private int age;      //年龄
     static String room;   //static修饰的所在教室

     public Student() {
     }

     public String getName() {
         return name;
     }

     public void setName(String name) {
         this.name = name;
     }

     public int getAge() {
         return age;
     }

     public void setAge(int age) {
         this.age = age;
     }

     public Student(String name, int age) {
         this.name = name;
         this.age = age;
     }
 }

Student类

 package cn.intcast.demo13;

 public class Code01Static {
     public static void main(String[] args) {
         Student one = new Student("梅超风",32);
         System.out.println("姓名："+one.getName()+"；年龄："+one.getAge());
         Student two = new Student("黄老邪",64);
         two.setName("王重阳");
         two.setAge(44);
         System.out.println("姓名："+two.getName()+"；年龄："+two.getAge());
         one.room = "404班";
         System.out.println("第二个人的班级是："+two.room);
     }
 }

运行结果图

5、若static修饰成员方法，那么该方法就是静态方法。静态方法不属于对象，而是属于类的。

如果没有static关键字，那么必须先创建对象，然后通过对象才能使用。对于静态方法来说，可以通过对象名进行调用，也可以直接通过类名称来调用。

 package cn.intcast.demo13;

 public class MyClass {
     public void method(){
         System.out.println("这是普通的成员方法");
     }
     public static void methodStatic(){
         System.out.println("这是静态方法");
     }
 }

MyClass

 package cn.intcast.demo13;

 public class CodeStatic {
     public static void main(String[] args) {
         //首先创建对象
         MyClass obj = new MyClass();
         //然后才能使用没有static关键字的内容
         obj.method();
         //对于静态方法来说，可以通过对象名进行调用，也可以直接通过类名称来调用。
         obj.methodStatic();               //正确，不推荐，这种写法在编译之后也会被javac翻译成为"类名称.静态方法名"
         MyClass.methodStatic();     //正确，推荐

     }
 }

CodeStatic

运行结果图

6、静态static的内存图

7、静态代码块

格式：

public class 类名称{

　　　　static{

　　　　　　　　//静态代码块

　　}

}

特点：当第一次用到本类时，静态代码块执行唯一一次。

静态内容总是优先于非静态。所以静态代码块比构造方法先执行。

典型用途：用来一次性的对静态成员变量进行赋值