【Java基础之多线程】代码库(二)_private static final flag=1-优快云博客

继承 Thread 类

/**
 * Java JVM 启动的时候会有一个进程 java.exe.
 * Java 进程中至少有一个线程负责 java 程序的执行, 运行的代码存在于 main() 函数中, 称之为主线程.
 * 实际上, JVM 的启动不止一个线程, 还有一个负责垃圾回收的线程. 
 */

public class SubsidiaryThread extends Thread {
    public void run() {
        for (int i = 0; i < 60; i++) {
            System.out.println("这是分线程在运行!!!" + i);
        }
    }
}


public class MainThread {
    public static void main(String[] args) {
        //实例化 SubsidiaryThread 对象, 就创建了一个新线程
        SubsidiaryThread st = new SubsidiaryThread();

        //调用 start() 方法执行线程(自动调用 run() 方法执行辅线程要做的事情)
        st.start();
        for (int i = 0; i < 60; i++) {
            System.out.println("这是主线程在运行!!!" + i);
        }
    }
}

实现 Runnable 接口.java

/**
 * 步骤:
 * 定义类实现 Runnable 接口,
 * 实现 Runnable 接口中的 run 方法,
 * 通过 Thread 类建立线程对象,
 * 把 Runnable 接口的子类对象, 作为实际的参数传递给 Thread 类构造函数(Thread(Runnable target) 分配新的 Thread 对象),
 * 调用 Thread 类的 start() 方法开启线程(自动调用 Runnable 接口子类的 run() 方法).
 */

public class Ticket implements Runnable {
    private int ticket = 100;

    public void run() {
        while(ticket > 0) {
            System.out.println(Thread.currentThread().getName() + "-->sale:" + ticket--);
        }
    }
}

public class MainThread {
    public static void main(String[] args) {
        //创建新的线程实例
        Ticket ticket = new Ticket();

        /** 启动新的线程对象 **/
        new Thread(ticket).start();
        new Thread(ticket).start();
        new Thread(ticket).start();
        new Thread(ticket).start();
    }
}

线程插队运行.java

/**
 * 在编写多线程程序时, 如果让一个线程优先于其他线程运行的状况, 除了可以设置该线程的优先级高于其他线程外, 
 * 更直接的方式就是使用 Thread 类的 join() 和 yield() 方法.
 */

public class JoinThread implements Runnable {
    public static void main(String[] args) throws InterruptedException {
        Thread lt = new Thread(new JoinThread());
        lt.start(); //分线程 start，不是立即执行
        System.out.println("Hello!"); //执行主线程
        lt.join(); //A.join() 阻塞当前线程 B，直至 A 执行完
        System.out.println("What the hell just happened?");
    }

    public void run() {
        System.out.println("A");
        System.out.println("B");
        System.out.println("C");
    }   
}

/**
 * 输出结果为：
 * Hello!
 * A
 * B
 * C
 * What the hell just happened?
 */

线程死锁.java

/**
 * 在编写多线程程序时, 必须注意资源的使用情况, 如果两个线程分别拥有不同的资源, 而又同时需要对方释放资源才能继续运行, 就会导致死锁!
 */

public class DeadLock implements Runnable {
    private boolean flag;
    private static final Object o1 = new Object();
    private static final Object o2 = new Object();

    public void run() {
        String threadName = Thread.currentThread().getName(); //获得当前线程名称
        System.out.println(threadName + ": flag =" + flag); //输出当前线程的 flag 变量值

        if (flag == true) {
            synchronized(o1) { //加锁
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(threadName + "进入 o1 准备进入 o2");
                synchronized(o2) {
                    System.out.println(threadName + "已经进入 o2");
                }
            }
        }

        if (flag == false) {
            synchronized(o2) {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(threadName + "进入 o2 准备进入 o1");
                synchronized(o1) {
                    System.out.println(threadName + "已经进入 o1");
                }
            }
        }
    }

    public static void main(String[] args)
    {
        DeadLock dl1 = new DeadLock();
        DeadLock dl2 = new DeadLock();

        dl1.flag = true;
        dl2.flag = false;

        //启动新线程运行
        new Thread(dl1).start();
        new Thread(dl2).start();
    }
}