多线程入门篇

创建线程的三种方式

继承Thread类，重写run方法

Thread类中有字段target为Runnable接口的实例，run方法不经过重写会默认执行target的run方法。

 重写后调用该类的start方法即可交给JVM创建一个新的线程执行run中的指令

这种方法的优点是写着简单

缺点是Java没有多继承，继承Thread就不能继承其他类，灵活性低

实现Runnable接口

Runnable是一个函数式接口，只有一个抽象方法run

实现Runnable接口和run方法后可以创建一个Thread的实例，传入一个Runnable接口实例赋给Thread中的target字段，以此来调用其start方法来创建新线程。具体的操作可以用接口回调或者lambda表达式来实现

接口回调

class exam1 implements Runnable{
    private void doSomething() {
    }
    @Override
    public void run() {
        doSomething();
    }
    static {
        Thread thread=new Thread(new exam1());
    }
}

 Lambda

因为Runnable是一个函数式接口(@Functionalnterface)，可以通过Java8中新增加的Lambda来实现

Thread thread=new Thread(()-> doSomething());

实现Callable接口

 观察Callable接口和Runnable接口的不同，call方法可以有返回值，并且可以抛出错误，是功能更完善的Runnable

使用方法，借助FutrueTask（实现了Runnable接口）来使用，FutrueTask中的run方法会执行传入Callable实例的call方法

        FutureTask futureTask=new FutureTask(()->{
            while(true){
                System.out.println("thread a");
            }
        });
        Thread thread=new Thread(futureTask);
        thread.start();

实质上还是执行的run方法，下面是FutureTask源码 

FutureTask状态转换

NEW：表示一个新的任务，初始状态。
COMPLETING：当任务被设置结果时，处于COMPLETING状态，这是一个中间状态。
NORMAL：表示任务正常结束。
EXCEPTIONAL：表示任务因异常而结束。
CANCELLED：任务还未执行之前就调用了cancel(true)方法，任务处于CANCELLED。
INTERRUPTING：当任务调用cancel(true)中断程序时，任务处于INTERRUPTING状态，这是一个中间状态。
INTERRUPTED：任务调用cancel(true)中断程序时会调用interrupt()方法中断线程运行，任务状态由INTERRUPTING转变为INTERRUPTED。

 

脏读

类似于数据库中的脏读问题，是由于在线程A中读取到了线程B尚未提交的数据，随后B回滚事务，导致线程A读取到了根本不存在的数据。

demo：

        Data data=new Data("name",100);
        Thread thread=new Thread(()->{
            //记录旧的数据
            int oldData=data.data;
            String oldString= data.name;
            data.name="dirtyData";
            try {
                Thread.currentThread().sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            data.data=0;
            //判定是否需要回滚
            if(data.data==0) {
                //回滚
                data.data=oldData;
                data.name=oldString;
            }
        });
        thread.start();
        Thread.currentThread().sleep(100);
        System.out.println("name== "+data.name);
        System.out.println("data== "+data.data);

不可重复读

不可重复读是指一个线程前后两次读取的数据不一致

死锁

类似于数据库中的死锁，各个线程之间的等待关系形成了一个环，导致这个进程陷入空等

demo:

        //注意s1和s2必须不一样，否则jvm会自动将s1与s2视作同一实例
        String s1="s1";
        String s2="s2";
        new Thread(()->{
            synchronized (s1){
                try {
                    System.out.println("锁s1并且暂停");
                    Thread.currentThread().sleep(3000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized (s2){
                }
            }
            System.out.println("Thread a over");
        }).start();
        synchronized (s2){
            try {
                System.out.println("锁s2并且暂停");
                Thread.currentThread().sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            synchronized (s1){
            }
        }
        System.out.println("Thread b over");

锁--synchronized和Lock的使用

synchronized

这个关键字的作用是给实例方法，静态方法，代码块（this|object）加锁，使得他们变成线程安全的

对于普通同步方法，锁是当前实例对象。

对于静态同步方法，锁是当前类的Class对象。

对于同步方法块，锁是Synchonized括号里配置的对象。

提一句synchronized的锁信息会存储在内存中对象存储区域中对象头中，更具体的说是存储在标记字段

Lock

JDK1.5之后引入了新的Lock锁，目的是提升锁的灵活性

Lock接口中有五个方法（tryLock重载一次）作用分别如下

//获取锁，不会自动释放锁，需要手动释放，使用的时候可以用try catch结构在finally代码块里释放锁
void lock();
//有返回值的获取锁，如果成功则返回true，这个方法可以避免死锁
boolean tryLock();
//第一个参数是时间，第二个是时间单位，TimeUnit枚举类型
boolean tryLock(long time, TimeUnit unit) throws InterruptedException;
//释放锁
void unlock();
//相当于可以响应中断的trylock（）方法
void lockInterruptibly() throws InterruptedException;
Condition newCondition();

Lock在JDK中的实现类只有ReentrantLock一个，意思是可重入锁，也就是一个线程获取锁以后可以再次获取锁，不会出现死锁的情况

Lock避免死锁

同样是上面死锁的例子，改写使其无法死锁

public static void main(String[] args) throws InterruptedException {
        Lock lock1 = new ReentrantLock();
        Lock lock2 = new ReentrantLock();
        doSomething(lock1,lock2);
        doSomething(lock2,lock1);

    }
    public static void doSomething(Lock lock1,Lock lock2){
        new Thread(()->{
            while(true) {
                try {
                    if(lock1.tryLock(1,TimeUnit.SECONDS)){
                        Thread.sleep(50);
                        if(lock2.tryLock(1,TimeUnit.SECONDS)){
                            System.out.println("success");
                            break;
                        }else{
                            lock1.unlock();
                            continue;
                        }
                    }else{
                        continue;
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

            }
            lock1.unlock();
            lock2.unlock();
        }).start();
    }