多线程-学习笔记

多线程创建

 

 在spring 中还可以注解支持创建

 

 实例如下

1Thread

 

 2Rundable

也可以尝试用lamda表达式的两种写法简化代码

 

 3callable

 

 4 线程池

 

 5spring注解，一个注解就能异步的开线程帮我们操作，从而不用占用主线程（在loginManage类中）

 

 

 

 然后想用的时候结合线程池调用就行

 

 然后就是停止线程

1用一个标志（优雅的停止）

 

 然后就不需要调用stop因为怕线程在执行然后强制停止造成不安全

 

 线程的五种状态

 

 

多线程最容易出现的问题就是同步问题，同时执行+i这个值，导致错误或者线程安全

比如我们需要加一个值一般是i++，在多线程里防止出错就加锁

多线程安全一般的解决方案就是加锁synchronized

如

 

 这样出票就不会错，但是感觉加了锁就像单线程一样。椅子执行完才其他线程执行。

 

 但是如果加了static就不使用this，因为我们知道static方法就是没有this的方法

详细可以看这里https://www.cnblogs.com/dolphin0520/p/3799052.html

所以它使用的是当前类的字节码

 

 

 

 既然都看了synchronized那肯定可以想到lock锁，他们两个都是线程安全的解决方案

 

点金Lock的源码

 

 

 声明再在有线程安全的地方调用

 

 

 

下面再来看看不加锁的情况下CAS,就是通过比较交换，比较交换

 

 或者用java原子类，也叫无锁

 

 也可以实现递增；

 

 并且效率高 ,为什么要看这些呢，因为不管是synchronized还是volatile，CAS等，底层都是这个指令

 下面再看看如何使用synchronized保障线程：

看一个例子

 

 

 

 

 

 以为加了锁就会不出错吗，答案是错误的

　　因为这两把锁都不是同一个锁，因为他们两的this分别是他们自己类，this都不同

一个this代表:input一个this代表output类

那怎样使用同一把锁；

肯定是用一个全局变量使用锁呗，正好res是一个

 

 

 

 

 

 

 

 

 

 

 

 

java多线程之间的通讯wait notify

注意：wait()和notify()必须在synchronized中使用

wait():是当前线程休眠并且释放锁。

notify():唤醒另一个线程

实例：

class Res{
    private String name;
    private String sex;
    
    private boolean flag=false;
    
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getSex() {
        return sex;
    }
    public void setSex(String sex) {
        this.sex = sex;
    }
    
    public boolean isFlag() {
        return flag;
    }
    public void setFlag(boolean flag) {
        this.flag = flag;
    }
    @Override
    public String toString() {
        return "Res [name=" + name + ", sex=" + sex + "]";
    }
    
}

/**
 * 生产者(写入线程)
 * @author Administrator
 *
 */
class InputThread extends Thread{
    Res res;
    int count=0;
    public InputThread(Res res) {
        this.res=res;
    }
    @Override
    public void run() {
        while(true) {    
            synchronized (res) {
                if(res.isFlag()) {
                    try {

                        //当前线程进入睡眠
                        res.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                if(count==0) {//偶数
                    res.setName("张三丰");
                    res.setSex("男");
                }else {//奇数
                    res.setName("李冰冰");
                    res.setSex("女");
                }

                //算奇、偶数的
                count=(count+1)%2;
                //设置标识
                res.setFlag(true);

                //唤醒out线程
                res.notify();
            }            
        }
    }
}

/**
 * 消费者(输出线程)
 * @author Administrator
 *
 */
class OutThread extends Thread{
    Res res;
    public OutThread(Res res) {
        this.res=res;
    }
    @Override
    public void run() {
        while (true) {
            synchronized (res) {
                if(!res.isFlag()) {
                    try {

                        //当前线程进入睡眠
                        res.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                System.out.println(res);        
                res.setFlag(false);

                //唤醒input线程
                res.notify();
            }            
        }
    }
}

public class ThreadCommunication {
    public static void main(String[] args) {
        Res res=new Res();
        InputThread input=new InputThread(res);
        OutThread out=new OutThread(res);
        input.start();
        out.start();
    }
}

输出结果为：

Res [name=张三丰, sex=男]
Res [name=李冰冰, sex=女]
Res [name=张三丰, sex=男]
Res [name=李冰冰, sex=女]
Res [name=张三丰, sex=男]
Res [name=李冰冰, sex=女]
Res [name=张三丰, sex=男]
Res [name=李冰冰, sex=女]
Res [name=张三丰, sex=男]

 多线程之join线程优先级

join的底层很有意思，是基于wait和notify实现的，用的锁是this锁

想实现优先级保障线程顺序问题

 

 join在这里面就是操控主线程，让主线程wait等t1先执行，也就是因为主线程没醒，后面的线程也创建不了，从而这样实现顺序，并优先级

整个过程就是，程序运行，主线程运行，执行到t1，start，然后主线程和t1此时可能还是一起的，多线程并行，但是主线程继续执行碰到join，然后主线程就阻塞了

然后等t1执行完join完了，主线程notify然后执行t2又重复。也就是说join操控的是主线程的this锁，而join底层又是wait notify

所以下面这样根本没用，反面教材