java体系之线程篇

面试题：

1、java多线程创建方式有几种？

2、线程安全的解决办法（同步）有几种？

3、sleep（）和 wait（）的异同？

4、synchronize和lock的区别？

5、wait（）、notify（）、notifyAll（）、各个用法？

6、启动一个线程能否不调用start（）？

7、调用start（）执行方法和调用run(  )执行方法有什么区别？

8、一个线程启动后没有关闭能否再次调用start（）？

9、为什么说实现callable接口比runnable接口强大？

10、线程池的好处？

11、程序，进程，线程、并发、并行的理解。

12、线程的生命周期。

13、同步方法的总结。

------------------------------------------------解答----------------------------------------------------

一、java多线程的创建方式有几种？

1）继承Thread类，重写run方法。

class MyThread extends Thread {
    //2. 重写Thread类的run()
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            if(i % 2 == 0){
                System.out.println(Thread.currentThread().getName() + ":" + i);
            }
        }
    }
}

public class ThreadTest {
    public static void main(String[] args) {
        //3. 创建Thread类的子类的对象
        MyThread t1 = new MyThread();

        //4.通过此对象调用start():①启动当前线程 ② 调用当前线程的run()
        t1.start();
        //问题一：我们不能通过直接调用run()的方式启动线程。
//        t1.run();

        //问题二：再启动一个线程，遍历100以内的偶数。不可以还让已经start()的线程去执行。会报IllegalThreadStateException
//        t1.start();
        //我们需要重新创建一个线程的对象
        MyThread t2 = new MyThread();
        t2.start();

        //如下操作仍然是在main线程中执行的。
        for (int i = 0; i < 100; i++) {
            if(i % 2 == 0){
                System.out.println(Thread.currentThread().getName() + ":" + i + "***********main()************");
            }
        }
    }

}

2）实现Runnable接口，重写run方法。

//1. 创建一个实现了Runnable接口的类
class MThread implements Runnable{

    //2. 实现类去实现Runnable中的抽象方法：run()
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            if(i % 2 == 0){
                System.out.println(Thread.currentThread().getName() + ":" + i);
            }

        }
    }
}

public class ThreadTest1 {
    public static void main(String[] args) {
        //3. 创建实现类的对象
        MThread mThread = new MThread();
        //4. 将此对象作为参数传递到Thread类的构造器中，创建Thread类的对象
        Thread t1 = new Thread(mThread);
        t1.setName("线程1");
        //5. 通过Thread类的对象调用start():① 启动线程 ②调用当前线程的run()-->调用了Runnable类型的target的run()
        t1.start();

        //再启动一个线程，遍历100以内的偶数
        Thread t2 = new Thread(mThread);
        t2.setName("线程2");
        t2.start();
    }

}

3）实现Callable接口，重写call（）方法。

//1.创建一个实现Callable的实现类
class NumThread implements Callable{
    //2.实现call方法，将此线程需要执行的操作声明在call()中
    @Override
    public Object call() throws Exception {
        int sum = 0;
        for (int i = 1; i <= 100; i++) {
            if(i % 2 == 0){
                System.out.println(i);
                sum += i;
            }
        }
        return sum;
    }
}

public class ThreadNew {
    public static void main(String[] args) {
        //3.创建Callable接口实现类的对象
        NumThread numThread = new NumThread();
        //4.将此Callable接口实现类的对象作为传递到FutureTask构造器中，创建FutureTask的对象
        FutureTask futureTask = new FutureTask(numThread);
        //5.将FutureTask的对象作为参数传递到Thread类的构造器中，创建Thread对象，并调用start()
        new Thread(futureTask).start();

        try {
            //6.获取Callable中call方法的返回值
            //get()返回值即为FutureTask构造器参数Callable实现类重写的call()的返回值。
            Object sum = futureTask.get();
            System.out.println("总和为：" + sum);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }

}

4）使用线程池创建。

class NumberThread implements Runnable{

    @Override
    public void run() {
        for(int i = 0;i <= 100;i++){
            if(i % 2 == 0){
                System.out.println(Thread.currentThread().getName() + ": " + i);
            }
        }
    }
}

class NumberThread1 implements Runnable{

    @Override
    public void run() {
        for(int i = 0;i <= 100;i++){
            if(i % 2 != 0){
                System.out.println(Thread.currentThread().getName() + ": " + i);
            }
        }
    }
}

public class ThreadPool {

    public static void main(String[] args) {
        //1. 提供指定线程数量的线程池
        ExecutorService service = Executors.newFixedThreadPool(10);
        ThreadPoolExecutor service1 = (ThreadPoolExecutor) service;
        //设置线程池的属性
//        System.out.println(service.getClass());
//        service1.setCorePoolSize(15);
//        service1.setKeepAliveTime();

        //2.执行指定的线程的操作。需要提供实现Runnable接口或Callable接口实现类的对象
        service.execute(new NumberThread());//适合适用于Runnable
        service.execute(new NumberThread1());//适合适用于Runnable

//        service.submit(Callable callable);//适合使用于Callable
        //3.关闭连接池
        service.shutdown();
    }

}

二、实现同步的方式有哪些？

1）同步代码块

2）同步方法

 

3）lock锁

class Window implements Runnable{

    private int ticket = 100;
    //1.实例化ReentrantLock
    private ReentrantLock lock = new ReentrantLock();

    @Override
    public void run() {
        while(true){
            try{

                //2.调用锁定方法lock()
                lock.lock();

                if(ticket > 0){

                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }

                    System.out.println(Thread.currentThread().getName() + "：售票，票号为：" + ticket);
                    ticket--;
                }else{
                    break;
                }
            }finally {
                //3.调用解锁方法：unlock()
                lock.unlock();
            }

        }
    }
}

三、sleep（）和wait（）的异同？

相同点：这俩个方法一旦执行，都会使执行此方法的线程进入阻塞状态。

不同点：1）sleep（）是Thead类中定义的静态方法，wait（）是object类定义的方法。

              2）sleep（）是任意场景都可以调用，而wait（）只允许在同步方法或同步代码块中使用，并且由同一个同步监视器（锁）调用，由于同步代码块锁可以是任意对象，所以wait（）只有定义在object（）中才可以被任意对象（锁）调用。

             3）sleep（）执行完不会释放锁，而wait（）执行完毕会自动释放锁对象。

四、synchronize和lock的区别？

相同点：二者都是用来解决线程安全问题的。

不同点：synchronized机制是，执行完相应的逻辑会自动释放锁。而lock需要手动启动同步和结束同步。lock接口的实现类ReentrantLock,创建对象使用lock（）启动同步和unlock（）结束同步。

五、wait（）、notify（）、notifyAll（）、各个用法？

1）wait（）、notify（）、notifyAll（）这三个方法只可以在同步方法和同步代码块中使用。

2）wait（）、notify（）、notifyAll（）这三个方法的调用者必须是同步方法和同步代码块中的同步监视器（锁），否则会报错。

3）wait（）、notify（）、notifyAll（）这三个方法定义在object类中，同步监视器是任意对象（锁），而这三个方法由它调用，所以这三个方法只有定义在object中才可以满足。

六、启动一个线程能否不调用start（）？

启动线程必须走start（）。

七、调用start（）执行方法和调用run(  )执行方法有什么区别？

调用start（），有俩个功能分别是启动当前线程和调用当前线程的run（）。

调用run（），不会启动线程仅仅相当于普通对象调用了run（）。

八、一个线程启动后没有关闭能否再次调用start（）？

不可以，调用的话会报错，-----IllegaThead

九、为什么说实现callable接口比runnable接口强大？

1）call（）可以有返回值。FutureTask  f = new FutureTask( callable实现类的对象)

f.get(  )//返回为call( )的返回值

2）call（）可以抛异常。

3）callable支持泛型。

十、线程池的好处/

1)提高响应速度。

2)降低资源消耗。

3)便于线程管理。

十一、程序，进程，线程、并行、并发、串行的理解。

程序：一段静态的代码，为了完成某项特定任务，使用某种语言编写的一组指令的集合。

进程：把程序加载到内存中，程序的一个执行过程，或者正在执行的程序（任务管理器中的一个进程比如QQ\微信）

线程：程序内部的一条执行路径。每个线程都有自己的栈和程序计数器。多个线程共享同一个进程中的方法区和堆。

并行：多个CPU同时执行多个任务

并发：一个CPU（时间片）同时执行多个任务

串行：一个一个执行，比如收费站，收一个车的费用过一个，有一个不交后边的也不能过去。

十二、线程的生命周期

新建    new线程对象的时候。

就绪   调用start（），只是准备就绪了，并不是一直会执行，有可能一直在等待CPU的执行权。

运行   已经准备就绪的线程获得CPU的执行权，开始运行run（）中的逻辑操作。

阻塞   调用sleep（）或wait（）或者a线程调用B 线程的join（），a线程就会被挂起，等B线程执行完毕a线程才会执行。或者调用

             yield（）释放当前线程的执行权。

死亡    线程执行完操作、或者被强制终止、stop（）

十三、同步方法的总结

1） 同步方法仍然涉及到同步监视器，只是不需要我们显式的声明。
2） 非静态的同步方法，同步监视器是：this
3 ）静态的同步方法，同步监视器是：当前类本身   xxx.class