Java多线程并发入门（基础知识）

1.每个进程都拥有自己的一整套变量，线程共享数据。

2.共享变量使得线程之间通信更有效、容易。

3.关于Runnable函数式接口的问题参考我的博客：https://www.cnblogs.com/cckong/p/14264821.html

4.直接调用run方法只会在一个线程执行，是同步的，start方法是异步的。

我们知道Thread是实现Runnable接口的，但是调用start方法，是让线程进入了可执行态。如果调用run会当成普通方法调用。

5.线程状态（6个：新建、可运行、阻塞、等待、计时等待、终止）

这里是根据java Thread.state 官方表示的状态

在操作系统我们也有线程3种或者5种状态的说法

三种状态：就绪、运行、等待
五种状态：新建、就绪、运行、等待、退出

6.想要获取当前状态使用getState方法

7.当你new Thread时进入新建状态了

8.可运行状态取决于CPU处理器是否运行你，有可能在运行也有可能不在。

9.阻塞或等待状态原因：需要的资源的锁没有释放

等待另一个线程通知出现了一个条件

方法有超时参数，线程会进入计时等待阶段。

10.终止状态：run方法自然退出，线程自然终止

没有捕获的异常使线程意外终止

11.中断线程：interrupt方法请求终止一个线程，（阻塞的线程无法请求终止），最好捕获InterruptedException

12.守护线程：setDaemon(true)转换为守护线程。

13.异常

检查型异常：其他所有

非检查型异常：派生于Error类、RuntimeException类的异常。

14.run方法不能抛出任何检查型异常，但非检查型可能导致线程终止，或死亡。

15.针对上条，可以用处理未捕获异常的处理器，实现UncaughtExceptionHandler接口的类。

16.让线程调用setUncaughtExceptionHandler静态方法安装处理器。

17.线程优先级可以用setPriority方法1-10（不推荐声明优先级）

18.竞态条件：两个或以上线程对于共享数据的修改会让对象破坏，需要要同步存取。

例子：修改数字三步：读出数据，修改数据，写回数据。

线程A读出、修改了，这时候线程B杀了进来，完成了修改三部曲，A继续第三步，这时候数字就已经不对了

19.Reentrant类：重入锁

从JDK5引入。下面来看一个实例

 private ReentrantLock mylock=new ReentrantLock();

    public void transfer(int a)
    {
        
        mylock.lock();
        try {
            a++;
        }
        finally {
            mylock.unlock();
        }
    }

unlock操作一定要放在finally里面执行，不然其他线程永久阻塞。

20.用条件对象（if/while）来管理获得一个锁但不能做有用工作的线程。

例子：线程A进入修改数字程序，发现数字低于多少值不能修改了。

21.await方法线程暂停并放弃锁

signalAll方法重新激活所有等待此条件的线程（通知现在有可能满足条件，线程需自己去检查满足条件与否）

22。只要一个对象的状态发生变化，就signalAll所有等待线程来检查条件。

23.signal()唤醒指定线程。

24.总结锁和条件对象：

锁保护代码片段，一次只有一个线程执行代码

一个锁可以有一个或多个条件对象

锁管理进入保护代码的线程

条件对象管理进入保护代码但还不能运行的线程

24.synchronized关键字：

可以作为synchronized方法 或者 synchronized代码块

从Java1.0开始，每个对象都有一个内部锁。这个锁有一个内部条件

如果一个方法声明时有synchronized关键字对象的锁将保护整个方法代码

public synchronized void method()
{
    //body
}

等价于(intrinsic固有的）

public void method()
{
    this.intrinsicLock.lock();
    try{
        //body
    }
    finally{
        this.intrinsicLock.unlock();
    }
}

wait和notify的应用：

wait将线程添加到等待集里面

notify/notifyAll解除等待线程的阻塞

25.并发关键字使用推荐顺序：
(1)concurrent包里的机制，如阻塞队列

（2）synchronized关键字，减少代码量

（3）Lock/Condition

26.监视器monitor特型：

只包含私有字段的类

类中每个对象都有一个关联的锁

所有方法由这个锁锁定。

锁可以有任意多的相关条件。

27.监视器本质上就是os上的管程，https://www.cnblogs.com/noteless/p/10394054.html，这篇博客讲的非常清楚。

28.volatile关键字（英文翻译：不稳定的）提供免锁机制，编译器和jvm知道该字段有可能被另一个线程更新

29.

private boolean done；
public synchronized boolean isDone（）{ return done；}
public synchronized void setDone（）{done=false；}

同时调用两个方法，肯定会有一个加锁，另一个阻塞。

使用volatile关键字修改对其他所有线程可见。

private volatile boolean done；
public  boolean isDone（）{ return done；}
public  void setDone（）{done=false；}

30.假设对共享变量只有赋值的功能，可以使用volatile关键字。

31.stop（终止）不安全，suspend（阻塞）易导致死锁，resume（恢复suspend的线程）：都试图控制一个线程的操作，而不是线程互操作。

stop：结束所有未结束的方法，包括run方法，立即释放对象的锁，导致对象处于不一致状态。（转账，钱取出来了，还没放进别人账户，就是释放了，不安全）

因为调用stop的线程不清楚调用线程的状态！

suspend如果线程在拥有一个锁，然后被阻塞了，锁是不能释放的，会导致别的线程无法访问，导致死锁。

安全挂起线程：suspendRequested变量

32.并发的修改一个数据结构，很容易破环这个数据结构（链表的指针无效、混乱等）

33.可以并发的时候加锁来保证数据结构的安全，但不如选择线程安全的实现。

34.阻塞队列：

35.concurrentHashMap计数方法*如果映射太大会超出int）

36..concurrentHashMap默认支持16个书写器，通过构造器可以更多。

37.

38.对于并发散列映射

search搜索：为每个键或者值应用一个函数，直到生成一个非null的结果

reduce规约：组合所有键或值

foreach：所有键或值应用一个函数。

39.线程池：：包含很多准备运行的线程。

40.Callble和Runnable类似，封装一个call方法（函数式接口），但是有返回值，返回调用的类型。Callable<Integer> 就会返回Integer

public interface Callable<V>
{
    V call() throws Exception;
}

41.Future保存异步计算的结果，接口下的方法：
V get()调用后阻塞，直到计算完成

V get(long tiomeout,TimeUnit unit)调用后阻塞，在时间限制内计算完成返回，否则返回异常

void cancel(boolean mayInterrupt)取消计算，已经开始计算让它中断，没开始则取消

boolean isCancelled()是否取消

boolean isDone()是否完成

42.执行器（Executors）类中有很多静态工厂类方法来构造线程池

43.实现线程的三个方法

继承Thread类实现Runnable接口实现Callable接口

44.使用Thread类写一个线程

我们先观察一下线程调用run方法和start方法的区别

package com.Thread;

/**
 * @Description: 使用继承thread类 实现线程。重写run方法，在主函数用start调用
 * @Author: cckong
 * @Date: 2021/2/2
 */
public class Test01 extends Thread{
    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            System.out.println("run"+i);
        }
    }

    public static void main(String[] args) {
        Test01 test01=new Test01();
        test01.run();
        for (int i = 0; i < 20; i++) {
            System.out.println("main"+i);
        }
    }
}

我们可以看到run方法是执行完在执行其他的线程。

我们再看一下start方法

package com.Thread;

/**
 * @Description: 使用继承thread类 实现线程。重写run方法，在主函数用start调用
 * @Author: cckong
 * @Date: 2021/2/2
 */
public class Test01 extends Thread{
    @Override
    public void run() {
        for (int i = 0; i < 17; i++) {
            System.out.print("   start"+i);
        }
    }

    public static void main(String[] args) {
        Test01 test01=new Test01();
        test01.start();
        System.out.println("
");
        for (int i = 0; i < 17; i++) {
            System.out.print("   main"+i);
        }
    }
}

可以看出是交替执行的。（由CPU调度安排）

45.实现Runnable接口生成一个线程

package com.Thread;

/**
 * @Description: 实现Runnable接口 实现线程.先重写run方法，然后使用一个thread代理调用start方法
 * @Author: cckong
 * @Date: 2021/2/2
 */
public class Test02 implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 17; i++) {
            System.out.print("   start"+i);
        }
    }

    public static void main(String[] args) {
        Test02 test02=new Test02();
        new Thread(test02).start();
        
        
        for (int i = 0; i < 17; i++) {
            System.out.print("   main"+i);
        }
    }
}

我们可以看见也需要重写run方法。唯一的不同是需要new一个Thread来代理调用

46.二者区别

47.经典抢火车票问题

/**
 * @Description: 经典抢火车票例子
 * @Author: cckong
 * @Date: 2021/2/2
 */
public class Test03 implements Runnable{
    private int ticnum=10;

    @Override
    public void run() {
        while (true) {
            if(ticnum<=0) break;
            try {
                Thread.sleep(200);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "抢到了" + ticnum);
            ticnum--;
        }
    }

    public static void main(String[] args) {
        Test03 test03=new Test03();

        new Thread(test03,"黄牛").start();
        new Thread(test03,"小明").start();
        new Thread(test03,"小红").start();
        new Thread(test03,"老师").start();


    }
}

出现了很多并发的问题需要解决。

我们现在ticnum上加了 volatile关键字其作用是变量的更改对外可见

但还是无法保证安全性

48.经典龟兔赛跑问题

/**
 * @Description: 龟兔赛跑案例
 * @Author: cckong
 * @Date: 2021/2/2
 */
public class Test04 implements Runnable{
    private static String winner;//赢家的名字
    @Override
    public void run() {
        String user=Thread.currentThread().getName();
        int step=0;//记录当前步数
        for (int i = 0; i < 101; i++) {

            //这里是对于兔子树下睡觉的形象化 当线程用户是兔子时 十步歇一会
            if (user.equals("兔子") && step % 10 == 0) {
                try {
                    Thread.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            step++;//步数+1
            System.out.println(user+"已经跑了"+step+"步");

            if(win(step)) break;//当已经有了赢家了或者自己赢了 就停止循环
        }

    }
    //判断是否结束游戏了（已经存在赢家 自己赢了）
    public boolean win(int step)
    {
        if(winner!=null) return true;
        if(step>=100){
            winner=Thread.currentThread().getName();

            System.out.println(winner+"赢了");
            return true;

        }
        return false;
    }

    public static void main(String[] args) {
        Test04 test04=new Test04();

        new Thread(test04,"兔子").start();
        new Thread(test04,"乌龟").start();
//
//        System.out.println(winner+"赢了");
    }
}

49.实现callbale接口建立线程

/**
 * @Description: callable接口
 * @Author: cckong
 * @Date: 2021/2/3
 */
public class Test05 implements Callable<Boolean> {
    @Override
    public Boolean call() throws Exception {
        for (int i = 0; i < 17; i++) {
            System.out.print("   start"+i);
        }
        return true;//可以有返回值
    }

    public static void main(String[] args) {
        Test05 test05=new Test05();//创建一个线程
        ExecutorService executorService= Executors.newFixedThreadPool(1);//创建执行环境 并指定线程数
        Future<Boolean> r1=executorService.submit(test05);//提交线程


        System.out.println("
");
        for (int i = 0; i < 17; i++) {
            System.out.print("   main"+i);
        }

        boolean rs1=false;//默认false
        try {
            rs1 = r1.get();//获得返回值
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
        System.out.println(rs1);
        executorService.shutdownNow();//关闭服务


    }
}