Java 线程的基本使用

2020-03-21 16:01:46来源：博客园阅读 ()

Java 线程的基本使用

线程的2种实现方式

1、继承Thread类，重写run()方法

public class Thread1 extends Thread{

    @Override
    public void run() {
        //要执行的代码
        while (true){
            System.out.println("thread1 is running....");   
        }
    }

}

 Thread1 thread1 = new Thread1();
 thread1.start();

2、实现Runnable接口

public class MyRunnable implements Runnable{

    @Override
    public void run() {
        //要执行的代码
        while (true) {
            System.out.println("thread2 is running....");
        }
    }

}

MyRunnable myRunnable = new MyRunnable();
Thread thread2 = new Thread(myRunnable);
thread2.start();

相比而言，第一种要简单些。

我们测试下：

public class Test {

    public static void main(String[] args) {
        Thread1 thread1 = new Thread1();
        thread1.start();

        MyRunnable myRunnable = new MyRunnable();
        Thread thread2 = new Thread(myRunnable);
        thread2.start();
    }

}

运行，看到thread1、thread2交替执行

线程的start()方法是初始化一个线程、分配一条线程所需的资源，把这条线程放到调度队列中，让线程处于ready状态。获取到cpu的使用权时自动调用线程的run()方法执行代码。

如果是直接调用run()方法，那就只是在当前线程中调用一个类的一个方法，并没有使用多线程。

线程的6种状态

Thread类在内部枚举类中定义了6种状态：

public enum State {
        NEW,
        RUNNABLE,
        BLOCKED,
        WAITING,
        TIMED_WAITING,
        TERMINATED;
}

1、New 新建

new Thread()已经创建线程，但尚未调用start()启动线程

2、RUNNABLE 可运行

Java把就绪（ready）和运行（running）两种状态合并为一种状态：可运行（runnable）。

调用了start方法，线程就处于可运行状态（就绪）。此线程获取到时间片后，开始执行run()中的代码，处于运行（running）状态。

3、BLOCKED 阻塞

处于阻塞状态的线程并不会占用CPU资源。以下情况会让线程进入阻塞状态：

①等待获取锁

等待获取一个锁，而该锁被其它线程持有，则该线程进入阻塞状态。当其它线程释放了该锁，并且线程调度器允许该线程持有该锁时，该线程退出阻塞状态。

②IO阻塞

线程发起了一个阻塞式IO后也会进入阻塞状态，比如等待用户输入内容然后继续执行。

IO是很广的概念，包括磁盘IO、网络IO等。

4、WAITING 无限期等待

处于此种状态的线程不会被分配 CPU 时间片，需要被其它线程显式地唤醒，才会进入就绪状态。

以下3个方法会让线程进入无限等待状态

Object.wait() 结束：Object.notify() / Object.notifyAll()
Thread.join() 结束：被调用的线程执行完毕
LockSupport.park() 结束：LockSupport.unpark(currentThread)

5、TIMED_WAITING 限时等待

处于这种状态的线程也不会被分配CPU 时间片，但在指定时间之后会被系统自动唤醒，进入就绪状态。

以下3个方法会让线程进入限时等待状态：

Thread.sleep(time) 方法结束：sleep时间结束
Object.wait(time) 方法结束：wait时间结束，或者调用Object.notify() / notifyAll()
LockSupport.parkNanos(time)/parkUntil(time) 方法结束：park时间结束，或者调用LockSupport.unpark(currentThread)

处于阻塞状态、无限期等待、限时等待的线程都会让出cpu的使用权，阻塞结束、显式唤醒后进入就绪状态，需要重新获取时间片才能接着运行。

6、TERMINATED 死亡

线程结束任务之后自动消亡，或者线程执行时发生了异常而结束。

常用方法

1、获取当前线程

 Thread thread = Thread.currentThread(); //获取当前线程

2、查看线程信息

        Thread thread = Thread.currentThread(); //通过Thread类（或者其子类）对象来获取线程信息。只要是Thread类的对象都行，不一定要是当前线程对象
        System.out.println(thread.getId()); //线程id。
        System.out.println(thread.getName()); //线程名，不是线程对象名。主线程为main，其它为Thread-n，n从0开始
        System.out.println(thread.getPriority()); //优先级，未指定时默认为5
        System.out.println(thread.getState()); //线程状态。6种状态中的某一种

3、join() Thread的实例方法，在当前线程中加入另一条线程

public class Test {

    public static void main(String[] args) throws InterruptedException {
        Thread1 thread1 = new Thread1();
        thread1.start();
        thread1.join(); //在当前线程（此处是主线程）中加入线程thread1（把thread1加入当前线程中）。join()要放在start()之后
        //....
    }

}

如果不使用join()，2条线程会交替执行，使用join()之后，会先把加入的线程执行完，再执行当前线程。

4、yield() 线程让步，Thread类的静态方法

当前线程让出cpu的使用权，进入ready状态。

这个方法是不可靠的，不一定会真的让出来，视系统当前的运行状况而定。

5、sleep() Thread类的静态方法，使当前线程休眠指定时间

public class Thread1 extends Thread{

    @Override
    public void run() {
        System.out.println("thread1 is running...");

        try {
            Thread.sleep(500); //使当前线程休眠500ms，会让出cpu的使用权，500ms后自动苏醒，进入ready状态
　　　　　　  Thread.sleep(500,100); //精确到纳秒。参数：毫秒、纳秒
            Thread.sleep(0);  //触发操作系统立刻重新进行一次CPU竞争。
            // Thread1继承自Thead，也可以使用Thread1来操作
        } catch (InterruptedException e) { //如果在线程休眠时，此线程被中断，会抛出线程中断异常，并立即唤醒此线程，进入ready状态。因为线程的中断只能由线程本身来控制
            e.printStackTrace();
        }

        System.out.println("thread1 is running again...");
    }

}

6、wait()、notify()、notifyAll()

这三个方法需要控制对对象的控制权(monitor)，所以属于Object类，均为Object的实例方法。

这三个方法能够被调用的前提是已经获取了相应的互斥锁，所以这三个方法都只能在同步代码块中使用。

wait()，把持有该对象线程的对象控制权交出去（释放锁），然后处于等待状态。

notify()，会通知某个正在等待这个对象的控制权的线程可以继续运行（获取锁）。

nofifyAll()，会通知所有等待这个对象控制权的线程继续运行，如果有多个正在等待该对象控制权时，具体唤醒哪个线程，就由操作系统进行调度。

使用示例：

public class Thread1 extends Thread {
    public static Object lock = new Object(); //锁。可以把要使用的公共资源直接作为锁，比如大家都要使用的文件，也可以把一个Object对象作为锁，获取到锁后，才可以操作公共资源

    @Override
    public void run() {
        //....
        
        //同步代码块
        synchronized (lock){  //获取锁
            System.out.println("已获取到锁,开始使用资源");
            //.....
            try {
                lock.wait(); //让出cpu使用权，释放锁，进入WAITING状态（无限期等待），如果要继续运行，需要在其它线程中显式唤醒
　　　　　　　　　//wait(1000);  //进入TIMED-WAITING(限时等待状态)，指定时间后会自动唤醒，进入ready状态
　　　　　　　　　//wait(1000,100);  //精确到纳秒
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            //.....  //如果同步代码块中、wait()后面还有代码，被其它线程唤醒后进入ready状态，获取到时间片后需要重新获取锁后才能继续执行后面的代码
        }
        
        //.....  //如果同步代码块中、wait()后面没有代码，则被其它线程唤醒后进入ready状态，获取到时间片后就继续执行，无需获取锁
    }

}

public class Thread2 extends Thread {
    public static Object lock = Thread1.lock; //锁，要是同一个对象

    @Override
    public void run() {
        //....

        //同步代码块
        synchronized (lock){
            lock.notify();
            // lock.notifyAll(); 
            System.out.println("已获取到锁,开始使用资源");
            //.....
        }

        //..... 
    }

}

wait()让出锁后，这把锁分配给等待获取这个锁的哪个线程？

如果等待这个锁的某个线程在同步代码块中使用了notify()，则唤醒该线程，直接把锁分配给这个线程。

如果等待这个锁的那些线程都使用notifyAll()，则唤醒所有等待这把锁的线程，由操作系统调度，由操作系统决定分配给哪个线程。

public class Test {

    public static void main(String[] args) {
        Thread1 thread1 = new Thread1();
        thread1.start();

        Thread2 thread2 = new Thread2();
        thread2.start();
    }

}

需要先启动wait()方法所在的线程，再启动notify()方法所在的线程

锁怎么写？