Java基础——线程

Java基础——线程

1.创建线程的3种方式

在Java中创建线程就是创建一个Thread类或者Thread子类的对象。

方式一：继承Thread类

public class MyThread  extends Thread{
    //线程的核心方法，写我们要让线程执行的任务
    @Override
    public void run() {
        System.out.println("线程"+currentThread().getName()+"执行了。。");
    }
}

public class ThreadTest {
    public static void main(String[] args) {
        MyThread myThread = new MyThread();
        myThread.start();
    }
}

方式二：实现Runable接口，作为Thread的target创建线程

public class MyRunable implements Runnable {
    //线程的核心方法。Thread类实现了Runnable接口
    public void run() {
        System.out.println("线程"+Thread.currentThread().getName()+"执行。。。");
    }
}

public class RunnableTest {
    public static void main(String[] args) {
        MyRunable myRunable = new MyRunable();
        Thread thread1 = new Thread(myRunable);
        thread1.start();
    }
}

方式三：实现Callable接口。用FutureTask封装Callable对象，该FutureTask封装了Callable对象的Call方法的返回值。FutureTask对象作为target创建Thread

public class MyCallable implements Callable<Integer> {
    public Integer call() throws Exception {
        System.out.println("线程执行了~~~");
        return 0;
    }
}

public class MyCallableTest {
    public static void main(String[] args) {
        MyCallable myCallable = new MyCallable();
        FutureTask<Integer> futureTask = new FutureTask<Integer>(myCallable);
        Thread thread = new Thread(futureTask);
        thread.start();

        try {
            Integer result = futureTask.get();
            System.out.println("返回值"+result);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}

2、三种创建线程方式的区别？

继承Thread类的方式有继承的局限性，不能再继承其他父类。但是编程简单，使用this即可以获得当前线程。

实现Runnable、Callable接口的方式创建线程。避免了单继承的局限性，还可以继承其他父类。在这种情况下，多个线程可以共享一个target对象，所以非常适合多线程处理同一份资源的情况。但是编程稍微复杂，需要使用Thread.currentThrend()方法访问当前线程。实现Callable接口适合需要返回值的情况。

3、 start() 和 run()方法区别

start()方法是新开一个线程，此时的线程处于就绪状态（Runnable状态），可以和其他线程争夺cpu，就算此时主线程结束了，并不会影响该线程继续。当cpu执行该线程的时候，会去执行核心方法run()方法。

run()方法是线程的核心方法，当直接调用run()方法的时候不会新开一个线程，而只是简单的方法调用，依然在主线程中执行。

4.线程的生命周期

新建状态

使用 new 关键字和 Thread 类或其子类建立一个线程对象后，该线程对象就处于新建状态。它保持这个状态直到程序 start() 这个线程。

就绪状态

当线程对象调用了start()方法之后，该线程就进入就绪状态。就绪状态的线程处于就绪队列中，要等待JVM里线程调度器的调度。

运行状态

如果就绪状态的线程获取 CPU 资源，就可以执行 run()，此时线程便处于运行状态。处于运行状态的线程最为复杂，它可以变为阻塞状态、就绪状态和死亡状态。

阻塞状态

如果一个线程执行了sleep（睡眠）、suspend（挂起）、wait（等待）等方法，失去所占用资源之后，该线程就从运行状态进入阻塞状态。在睡眠时间已到或获得设备资源后可以重新进入就绪状态。阻塞状态可以分为三种：

①等待阻塞：运行状态中的线程执行 wait() 方法，使线程进入到等待阻塞状态。

②同步阻塞：线程在获取 synchronized 同步锁失败(因为同步锁被其他线程占用)。

③其他阻塞：通过调用线程的 sleep() 或 join() 发出了 I/O 请求时，线程就会进入到阻塞状态。当sleep() 状态超时，join() 等待线程终止或超时，或者 I/O 处理完毕，线程重新转入就绪状态。

死亡状态

一个运行状态的线程完成任务或者其他终止条件发生时，该线程就切换到死亡状态。

5、sleep 和 wait区别

sleep() 是 Thread 的静态方法；调用之后不会释放锁资源，当时见到了之后，会自己去争夺cpu的执行权。

wait属于 Object 的一部分，而不属于 Thread。wait() 会在等待时将线程挂起，而不是忙等待，并且只有在 notify() 或者 notifyAll() 到达时才唤醒。

notify() 方法，用来通知那些可能等待该对象的对象锁的其他线程。如果有多个线程等待，则线程规划器任意挑选出其中一个 wait()状态的线程来发出通知，并使它等待获取该对象的对象锁。

notifyAll() 方法，使所有原来在该对象上 wait 的线程统统退出 wait 的状态（即全部被唤醒，不再等待 notify 或 notifyAll，但由于此时还没有获取到该对象锁，因此还不能继续往下执行），变成等待获取该对象上的锁。