初步了解多线程

线程与进程的认识与联系

在生活中，我们打开qq、微信啊这些应用程序就相当于开启了一个进程。而当我们用这些软件中的功能，比如：看朋友圈、聊天、扫一扫等操作的时候。这些就相当于是进程了。

1.简单来说，进程：指在系统中正在运行的一个应用程序；一个程序可以执行多个任务（也就是线程）。它占独立的空间，每个进程保持各自运行状态，相互之间不会干扰，是并发执行的（并发指按先后顺序执行）。程序一旦运行就是进程；进程——资源分配的最小单位。
线程：系统分配处理器时间资源的基本单元，或者说进程之内独立执行的一个单元执行流。线程——程序执行的最小单位。一个进程可以拥有多个线程，多个线程之共享进程的地址空间以及一些进程级别的其他资源，但是各个线程拥有自己的栈空间。
这里说一下并发和并行

• 并发指的是多个线程操作一个资源，不是同时执行，而是交替执行，单核CPU，只不过因为cpu的时间片很短，速度太快，看起来同时执行。
• 并行才是真正的同时执行，多核cpu，每一个线程都可以使用一个单独的cpu资源来运行。
  2.进程与线程各自是如何交互的
  2.1进程：通过TCP/IP的端口进行交互。
  2.2线程：线程比较简单，有一大块共享内存，大家指针相同就都可以看到这块内存了。
  在使用中：多进程程序更健壮，多线程程序只要有一个线程死掉，那么对于其共享资源的其他线程也会产生影响，而一个进程死掉并不会对另外一个进程造成影响，因为进程有自己独立的地址空间。而且线程廉价，线程启动比较快，退出比较快，对系统资源的冲击也比较小。而且线程彼此分享了大部分核心对象(File Handle)的拥有权。
  在面试中还有一个问题经常会考到：进程 和线程的使用场景
  因为进程是资源分配的基本单位，线程是程序执行的最小单元。以及进程与线程之间的健壮性来考虑。
• 1）在程序中，如果需要频繁创建和销毁的就使用线程。因为进程创建和销毁开销很大（需要不停的分配资源），但是线程频繁的调用只是改变CPU的执行，开销小。
• 2）如果需要程序更加的稳定安全时，可以选择进程。如果追求速度，就选择线程。

3.线程的创建

• 1继承Thread类，重写run()（当前线程的执行逻辑）方法， 实现Runnable接口，重写run()方法

class MyThread extends Thread{

    @Override
    public void run() {
        System.out.println("hello world");
    }
}

class MyRunnable implements Runnable{
    @Override
    public void run() {
        System.out.println("implemnts Runnable to get a thread");
    }
}

class WatchTv extends Thread{
    @Override
    public void run() {
        System.out.println("watch TV");
    }
}

• 2 匿名线程，匿名类

public class TestDemo1 {
    public static void main(String[] args) {
        new Thread("watchTv"){
            @Override
            public void run() {
                System.out.println("watch TV");
            }
        }.start();

        new Thread("eating"){
            @Override
            public void run() {
                System.out.println("eating");
            }
        }.start();

• 3 实现Callable接口，重写call()方法

class CallableDemo implements Callable<Integer>{
//简单求和
    @Override
    public Integer call() throws Exception {
        int sum = 0;
        for(int i=0; i<=10000;i++){
            sum += i;
        }
        return sum;
    }
}

public class TestDemo2 {
    public static void main(String[] args) {
        /**
         * 通过Callable和FutureTask创建线程
         * a.创建Callable接口的实现类，同时实现call方法
         * b.创建Callable实现类的对象，使用FutureTask包装当前Callable对象，
         * FutureTask对象封装Callable对象中call方法的返回
         * c.使用FutureTask对象作为Thread的参数创建并且启动线程
         * d.调用FutureTask对象的get()来获取子线程执行的结果
         */
        //b
        Callable<Integer> callableDemo = new CallableDemo();
        FutureTask<Integer> task = new FutureTask<>(callableDemo);
        //c
        Thread thread = new Thread(task);
        thread.start();

        try {
            //d
            Integer result = task.get();
            System.out.println(result);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
    

}

线程六状态：

1.新建状态（New）
重写或实现了runnable方法且并未调用start方法，也就是：新建且尚未启动的线程处于此状态。

2.就绪状态（Runnable）
在Java虚拟机中执行的线程处于此状态。此状态说明了线程已经获得cpu的执行权力，但包含两种执行状态：
_1、Ready：线程可执行，但当前cpu被其他正在执行的线程占用，而处于等待中。
_2、Running：线程可执行，且正在cpu中处于执行状态。

3.阻塞状态（Blocked）
线程因与其他线程共用同一个锁对象，而该锁对象被其他线程所持有（其他线程的同步内的代码尚未执行完成），从而无法进入synchronized中的状态。

4.睡眠状态（Timed_waiting）
线程因调用sleep方法处于休眠状态中，规定时间后可醒来，回到可运行状态（Runnable）。

5等待状态（Waiting）
_1、进入无限等待状态：
（1） 线程拥有锁对象
（2） 线程调用wait方法
（3） 线程自动释放锁对象
_2、退等待状态：
（1）其他线程拥有本线程释放的同一个锁对象
（2）其他线程调用notify方法
完成以上两步，则处于无限等待的线程回到了阻塞状态（Blocked），这是因为其锁对象正被其他线程持有，自己并未获得。
（3）·被唤醒的线程再次持有锁对象，回到可运行状态（Runnable）。
以上步骤为等待唤醒机制的基础。

6.终止状态（Terminated）
线程最终状态，已退出的线程处于此状态。一般为线程内任务执行完毕、或调用已过时的stop方法。或者线程出错了。

线程中常用方法：

 start() 用来启动一个线程 将其添加一个线程组当中 此时线程就会处Runnable就绪状态

getPriority（）：获取当前线程的优先级

setPriority（）：设置当前线程的优先级

注意：线程优先级高，被CPU调度的概率大，但不代表一定会运行，还有小概率运行优先级低的线程。

isAlive（）：判断线程是否处于活动状态 （线程调用start后，即处于活动状态）

join（）：调用join方法的线程强制执行，其他线程处于阻塞状态，等该线程执行完后，其他线程再执行。有可能被外界中断产生InterruptedException 中断异常。

sleep（）：在指定的毫秒数内让当前正在执行的线程休眠（暂停执行）。休眠的线程进入阻塞状态。

yield（）：调用yield方法的线程，会礼让其他线程先运行。（大概率其他线程先运行，小概率自己还会运行）

interrupt()：中断线程

wait（）：导致线程等待，进入堵塞状态。该方法要在同步方法或者同步代码块中才使用的

notify（）：唤醒当前线程，进入运行状态。该方法要在同步方法或者同步代码块中才使用的

notifyAll（）：唤醒所有等待的线程。该方法要在同步方法或者同步代码块中才使用的
当然还有object中的一些简单方法。