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;
    }
}

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("这是静态方法");
    }
}

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();     //正确，推荐

    }
}

运行结果图

6、静态static的内存图

7、静态代码块

格式：

public class 类名称{

　　　　static{

　　　　　　　　//静态代码块

　　}

}

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

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

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