对线程和进程的理解

进程和线程的区别

        进程：是指运行后的程序，是操作系统分配系统资源（内存空间、CPU）的最小单位。

        线程：每个进程由一个或者多个进程组成，线程是CPU进行分配和调度的最小单位。

        1.内存方面：

        进程需要的资源更多（堆、方法区、本地方法区），线程更轻量级（栈、程序计数器）。

        线程共享所在进程的内存空间（堆、方法区、本地方法区）。

        2.创建和销毁以及上下文切换：

        进程需要更多时间和资源，线程更快。

        3.相互通信方面：

        进程之间的通信比较麻烦（RPC、网络），线程之间通信更容易（通过进程共享的内存空间）。

     浅谈并行和并发

        一个CPU内核一个时间段只能运行一个线程的指令，因为CPU执行的速度特别快所以感觉多个程序同时运行 。

并发：一个CPU在多个线程间来回切换执行，不是真正同时执行。

并行：多个CPU同时执行多个线程，是真正同时执行。

多线程的作用和应用场景

线程是程序指令的单独的执行路径，多线程同时执行，大大提高了程序的执行效率。

应用场景：

        1.多线程下载

        2.游戏（图形绘制、游戏控制、网络通信。。）

        3.互联网应用（服务器为每个用户单独开线程，相互不影响）。

线程的三种实现方式

1.继承Thread类

步骤：定义类继承Thread类，然后重写run方法，创建线程对象，调用start()方法。

/**
 * 使用Thread类实现自定义线程
 */
public class MyThread extends Thread{
    @Override
    public void run() {
        for (int i = 0; i <100 ; i++) {
            System.out.println(Thread.currentThread().getName()+"-------"+i);
        }
    }


    public static void main(String[] args) {
        MyThread myThread = new MyThread();
        //启动线程thread
        myThread.start();
        //主线程main
//        myThread.run();

        for (int i = 0; i <100 ; i++) {
            System.out.println(Thread.currentThread().getName()+"-------"+i);
        }
    }
}

疑问1： 执行run()和start()有什么区别？

调用run()方法是在主线程同步执行的，调用start后才会 启动新线程去执行。

疑问2：如果调用两次start会怎么样？

会抛出异常IllegalThreadStateException，线程是一次性的，不允许执行两次。

疑问3：多线程的执行顺序是怎么样？

多线程的执行是抢占式的，线程会去抢占CPU，抢到后执行自己的指令，执行过程中CPU可能被其它线程抢占，其它线程执行。

疑问4：上下文切换回原来的线程时，如何执行从哪里开始执行？

每个线程有自己的程序计数器，保存当前线程执行的行数，切换回来后继续执行下面的行代码。

2.实现Runnable接口

步骤：1.定义类实现Runnable接口，2.实现run方法，3.创建Thread对象，传入Runnable,调用start方法。

/**
 * 使用Runnable接口实现自定义线程
 */
public class MyRunable implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i <100 ; i++) {
            System.out.println(Thread.currentThread().getName()+"-------"+i);
        }
    }

    public static void main(String[] args) {
        //创建MyRunable对象，创建Thread对象
        MyRunable myRunable = new MyRunable();
        Thread thread = new Thread(myRunable);
        thread.start();

        //匿名内部类写法
        Thread thread1 = new Thread(new Runnable(){
            @Override
            public void run() {
                for (int i = 0; i <100 ; i++) {
                    System.out.println(Thread.currentThread().getName()+"-------"+i);
                }
            }
        });
        thread1.start();
        //lambda表达式写法
        Thread thread2 = new Thread(()->{
            for (int i = 0; i <100 ; i++) {
                System.out.println(Thread.currentThread().getName()+"-------"+i);
            }
        });
        thread2.start();
    }
}

 疑问：继承Thread类和实现Runnable两种方式的区别？

解答：1.Java是单继承的，继承Thread类就不能继承其它类，实现接口没有此限制。

           2. 继承Thread不强制要求重写run，实现Runnable强制要求。

          3.Runnable可以使用Lambda表达式，语法简介。

          推荐使用Runnable方式。

3.实现Callable接口

 使用Thread类和Runnable类都是没有返回值的，如果想要有返回值，可以使用Callable。

步骤：1.实现Callable接口，重写call（）方法，2.创建一个FutureTask对象传入Callable实现对象，3.创建Thread线程传入FutureTask对象，4.启动线程，5.通过FutureTask的get()方法获取返回值。

/**
 * 使用Callable接口自定义一个线程
 */
public class MyCallable implements Callable<Long> {
    @Override
    public Long call() throws Exception {
        long sum = 0;
        for (int i = 0; i <100000 ; i++) {
            sum += i;
        }
        return sum;
    }


    public static void main(String[] args) {
        //创建FutureTask对象，传入Callable对象
        FutureTask<Long> futureTask = new FutureTask<Long>(new MyCallable());
        //创建Thread对象，传入FutureTask对象
        Thread thread = new Thread(futureTask);
        //启动线程
        thread.start();
        try {
            //获取返回值
            Long value = futureTask.get();
            System.out.println(value);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}

线程的生命周期

 线程常用的方法：

        start()         启动线程

        stop()         停止线程

        setName(String)       设置名字

        getName()                 获得名字

        sleep(long)                睡眠

        suspend()                 挂起线程

        resume()                  恢复线程

        yield()                       放弃执行

        join()                         合并线程

        setPriority(int)           设置线程优先级

        setDaemon(boolean) 设置后台线程

停止线程

       如果使用 stop() 调用stop会停止线程，不会释放锁，可能导致死锁，一般是禁用stop。

        停止线程的办法：1.等待run执行完。2. 在run执行代码中加入条件，中途停止执行。

线程的睡眠

Thread类的静态方法 sleep(毫秒数)

Thread.sleep(毫秒) 阻塞住当前线程，当时间结束后线程自动唤醒

疑问：wait和sleep的区别？

解答：1.调用对象不同： wait是锁对象调用，sleep是当前线程调用。

           2.唤醒机制不同： 线程进入wait后，要通过锁对象notify/notifyAll唤醒，sleep当时间结束自动唤醒。

           3.锁释放不同：线程进入wait后，会自动释放锁，线程sleep不会释放锁。

线程的优先级

线程有优先级从低到高分为1~10，默认是5，线程优先级越高抢到CPU的几率越高，可以给执行更重要任务的线程设置更高的优先级。

  Thread thread1 = new Thread(() -> {
            for (int i = 0; i < 100; i++) {
                System.out.println(Thread.currentThread().getName() + "-->" + i);
            }
        });
        Thread thread2 = new Thread(() -> {
            for (int i = 0; i < 100; i++) {
                System.out.println(Thread.currentThread().getName() + "-->" + i);
            }
        });
        //设置优先级
        thread2.setPriority(Thread.MAX_PRIORITY);
        thread1.setPriority(Thread.MIN_PRIORITY);
        thread1.start();
        thread2.start();

  后台线程

后台线程也叫守护线程（精灵线程），后台线程的任务是为其它线程提供服务，当其它线程都死亡后，后台线程会自动死亡。

使用：setDaemon(true) 设置后台线程

应用场景：gc线程（垃圾收集器）就是典型的后台线程。

/**
 * 守护线程
 */
public class DaemonDemo {
    public static void main(String[] args) {
        Thread daemon = new Thread(()->{
            for (int i = 0; ; i++) {
                System.out.println(Thread.currentThread().getName()+"-------"+i);
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        //设置守护线程
        daemon.setDaemon(true);
        daemon.setName("守护线程");
        daemon.start();
        //被守护线程
        for (int i = 0; i < 3 ; i++) {
            Thread thread =new Thread(()->{
                for (int j = 0; j < 10 ; j++) {
                    System.out.println(Thread.currentThread().getName()+"-------"+j);
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            });
            thread.start();
        }
    }
}

合并线程

线程的执行是抢占式的，在线程内部可以合并其它线程，让其它线程的执行代码在当前线程前面执行，然后执行自己的指令。

/**
 * 合并线程
 */
public class JoinDemo {
    static Thread thread1=null,thread2=null;
    public static void main(String[] args) {
        thread1 = new Thread(()->{
            for (int i = 0; i <10; i++) {
                System.out.println(Thread.currentThread().getName()+"-------"+i);
                try {
                    //合并线程
//                    if(i==5){
//                        thread2.join();
//                    }
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        thread1.setName("合并线程1");
        thread1.start();

        thread2 = new Thread(()->{
            for (int i = 0; i <10; i++) {
                System.out.println(Thread.currentThread().getName()+"-------"+i);
                try {
                    if (i==5){
                        //合并线程
                        thread1.join();
                    }
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        thread2.setName("合并线程2");
        thread2.start();
    }
}