JavaEE笔记——多线程系列

CPU使用抢占式调度模式在多个线程间进行着高速的切换。对于CPU的一个核心而言，某个时刻，只能执行一个线程，而 CPU的在多个线程间切换速度相对我们的感觉要快，看上去就是在同一时刻运行。其实，多线程程序并不能提高程序的运行速度，但能够提高程序运行效率（比如说一个需要用户输入的程序，如果用户不输入，程序就不会往下执行，但是如果有多线程，那么等待的时间可以执行其他程序。），让CPU的使用率更高。

究竟是多线程执行程序好还是顺序执行程序好？当1000个程序员同时操作8核心的数据库时，这个问题应该怎么考虑？

答：应该是顺序执行好。因为切换程序需要时间，而1000个程序员同时操作数据库所需要切换程序的次数远不止1000次，浪费太多时间。而顺序执行程序只需要切换1000次。

同步（线程不安全）与异步（线程安全）

同步:排队执行 , 效率低但是安全.

异步:同时执行 , 效率高但是数据不安全.

并发与并行

并发：指两个或多个事件在同一个时间段内发生。（如一天内的并发量是多少）

并行：指两个或多个事件在同一时刻发生（同时发生）。

编写多线程程序

方式一：
- 要写一个继承Thread的类
- 将要执行的程序重写进run方法，但通过start方法来开启线程

Thread

Thread的使用

        public static void main(String[] args) {
        MyThread m = new MyThread();
        //主线程和m线程都是并行执行。抢占式调度，谁先抢到就执行谁
        m.start();//开启新的线程
        for (int i=0;i<10;i++){
            System.out.println("汗滴禾下土"+i);
        }
    }


public class MyThread extends Thread {

    /**
     * run方法就是线程要执行的任务方法
     */

    @Override
    public void run() {
        //这里的代码 就是一条新的执行路径。
        //这个路径的触发方式，不是调用run方法，而是通过thread对象的start()来启动
        for (int i=0;i<10;i++){
            System.out.println("锄禾日当午"+i);
        }
    }
}

程序执行逻辑

Runnable

public static void main(String[] args) {
    //实现Runnable
    //1.创建一个任务对象
    MyRunnable r = new MyRunnable();
    //2.创建一个线程，并为其分配一个任务
    Thread t = new Thread(r);
    //3.执行这个线程
    t.start();
    for (int i=0;i<10;i++){
        System.out.println("疑是地上霜"+i);
    }
}

/**
 * 用于给线程进行执行的任务
 */
public class MyRunnable implements Runnable {
    @Override
    public void run() {
        //线程的任务
        for (int i=0;i<10;i++){
            System.out.println("床前明月光"+i);
        }
    }
}

Runnable与Thread对比的优势

实现Runnable 与继承Thread相比有如下优势：

1.通过创建任务，然后给线程分配的方式来实现的多线程，更适合多个线程同时执行相同任务的情况。
2.可以避免单继承所带来的局限性。
3.任务与线程本身是分离的，提高了程序的健壮性
4.后续学习的线程池技术，接受Runnable类型的任务，不接受Thread类型的线程。

Thread类常用方法

设置和获取线程名称

设置名称：new Thread(new MyRunnable(),名称)

获取名称：.currentThread().getName()

线程休眠：Thread.sleep(时间:单位毫秒);

Thread.currentThread().getName()
new Thread(new MyRunnable(),"锄禾日当午").start();

public static void main(String[] args) {
    System.out.println(Thread.currentThread().getName());
    new Thread(new MyRunnable(),"锄禾日当午").start();
    new Thread(new MyRunnable()).start();
}

static class MyRunnable implements Runnable{

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName());
    }
}

线程阻塞

线程阻塞：线程中所有比较消耗时间的操作。如文件读取，接收用户输入，线程休眠等。

线程中断

一个线程是一个独立的执行路径，它是否应该结束，应该由其自身决定。

//给线程t1添加中断标记
t1.interrupt(); //在sleep的时候，程序会检查t1有没有中断标记，如果有，就进入catch块。

try {
    Thread.sleep(1000);
} catch (InterruptedException e) {
    System.out.println("发现了中断标记，但是我们这个线程自杀");
    return;//run方法是线程的任务，这方法完毕就表示任务执行完毕了，所以return就代表了线程结束。
    //e.printStackTrace();
}

守护线程

线程：分为守护线程和用户线程
用户线程：当一个进程不包含任何的存活的用户线程时，进程结束
守护线程：守护用户线程的，当最后一个用户线程结束时，所有守护线程自动死亡。
能创建的线程都是用户线程
一定要在线程启动之前设置为守护线程

设置为守护线程的方法

线程名称.setDaemon(true);//设置为守护线程

线程安全问题

解决线程安全问题

1.同步代码块

格式：synchronized(锁对象)｛同步的代码内容｝

创建锁对象：private Object o = new Object();//创建锁对象

注意：锁对象必须在run（）方法前面定义的类属性变量，这样才是多个线程使用同一把锁，只有这样才能有效。如果在run（）方法内部定义的锁对象，每个线程在执行run（）任务时，都创建了不同的锁，不能实现多个线程排队执行的操作。

功能：多个线程排队执行，只有当一个锁对象的线程执行完，被释放后，下一个线程锁对象才会执行同步的代码内容。

先启动的线程抢到锁的几率比后启动的线程大。
谁先抢到的，那么其连续抢到的几率就比较高（因为自己释放锁，相比其他线程来说，自己距离锁最近。所以反手又抢到自己的锁，）

2.同步方法

格式：在方法前加synchronized修饰符

例：public synchronized boolean sale(){｝

同步方法的锁：

如果不是static静态方法，那么锁对象就是this(即创建的任务对象)，因此线程的任务对象必须是同一个，不能每个线程都new一个任务对象。这样就不是多个线程使用一个锁了。
如果是static静态方法，那么锁对象就是类名.class
当一段程序同时使用一个或多个同步代码块（和/或）同步方法，并且使用同一把锁this，那么只有一个同步代码块/同步方法执行完成，另外一个才能执行。

3.显式锁Lock

创建锁对象： ReentrantLock l = new ReentrantLock();

使用：

在程序开始前上锁。l.lock()
在程序结束后解锁。l.unlock()

隐式锁sync和显式锁lock的区别

在面试的过程中有可能会问到：在Java并发编程中，锁有两种实现：使用隐式锁和使用显示锁分别是什么？两者的区别是什么？所谓的显式锁和隐式锁的区别也就是说说Synchronized(下文简称：sync)和lock(下文就用ReentrantLock来代之lock)的区别。

本文主要内容：将通过七个方面详细介绍sync和lock的区别。通过生活case中的X二代和普通人比较大家更容易理解这两者之间的区别

Java中隐式锁：synchronized；显式锁：lock

一：出身不同

从sync和lock的出身(原始的构成)来看看两者的不同。

Sync:Java中的关键字，是由JVM来维护的。是JVM层面的锁。

Lock：是JDK5以后才出现的具体的类。使用lock是调用对应的API。是API层面的锁

sync是底层是通过monitorenter进行加锁（底层是通过monitor对象来完成的，其中的wait/notify等方法也是依赖于monitor对象的。只有在同步块或者是同步方法中才可以调用wait/notify等方法的。因为只有在同步块或者是同步方法中，JVM才会调用monitory对象的）；通过monitorexit来退出锁的。

而lock是通过调用对应的API方法来获取锁和释放锁的。

我们通过Javap命令来查看调用sync和lock的汇编指令：

编辑

从编译后的汇编指令，我们也能够清晰的看出sync关键字和lock的区别。

第一不同一句话概述：可以把sync理解为官二代或者是星二代。从娘胎出来自带光环的。Lock就是我们普通努力上进的人。

二：使用方式不同

Sync是隐式锁。Lock是显示锁

所谓的显示和隐式就是在使用的时候，使用者要不要手动写代码去获取锁和释放锁的操作。

我们大家都知道，在使用sync关键字的时候，我们使用者根本不用写其他的代码，然后程序就能够获取锁和释放锁了。那是因为当sync代码块执行完成之后，系统会自动的让程序释放占用的锁。Sync是由系统维护的，如果非逻辑问题的话话，是不会出现死锁的。

在使用lock的时候，我们使用者需要手动的获取和释放锁。如果没有释放锁，就有可能导致出现死锁的现象。手动获取锁方法：lock.lock()。释放锁：unlock方法。需要配合tyr/finaly语句块来完成。

两者用法对比如下：

编辑

用生活中的一个case来形容这个不同：官二代和普通人的你在进入机关大院的时候待遇。官二代不需要出示什么证件就可以进入，但是你需要手动出示证件才可以进入。

三：等待是否可中断

Sync是不可中断的。除非抛出异常或者正常运行完成

Lock可以中断的。中断方式：

1：调用设置超时方法tryLock(long timeout ,timeUnit unit)

2：调用lockInterruptibly()放到代码块中，然后调用interrupt()方法可以中断

生活中小case来理解这一区别：官二代一般不会做饭。都会去餐厅点餐等待着餐厅出餐。普通人的你既可以去餐厅等待，如果等待时间长的话，你就可以回去自己做饭了。

四：加锁的时候是否可以公平

Sync;非公平锁

lock：两者都可以的。默认是非公平锁。在其构造方法的时候可以传入Boolean值。

true：公平锁

false：非公平锁

生活中小case来理解这个区别：官二代一般都不排队，喜欢插队的。普通人的你虽然也喜欢插队。但是如果遇到让排队的情况下，你还是会排队的。

Lock的公平锁和非公平锁：

五：锁绑定多个条件来condition

Sync:没有。要么随机唤醒一个线程；要么是唤醒所有等待的线程。

Lock:用来实现分组唤醒需要唤醒的线程，可以精确的唤醒，而不是像sync那样，不能精确唤醒线程。

六：从性能比较

生活小case理解：在我们一般的认知中，官二代一般都是比较坑爹的吧。但是这几年也有很多官二代或者是富二代改变了态度，端正自己态度，靠自己能力而不是拼爹了。

七：从使用锁的方式比较

公平锁与非公平锁

公平锁：解锁后，所有线程排队执行。

非公平锁：解锁后，所有线程抢占式执行，谁先抢到就执行谁。上面的三个锁都是非公平锁。

公平锁的实现：

//显式锁 l:fair参数为true 就表示公平锁
private ReentrantLock l = new ReentrantLock(true);

线程死锁

出现的原因：一个有锁的方法调用了另外一个有锁的方法。

解决方法：不要出现锁调锁的情况。

多线程通信问题

什么是多线程通信问题?

举例：现在有两个线程，一个是下载音乐的线程A，一个是播放音乐的线程B。线程A执行完后要告诉线程B开始执行，这就涉及两个线程的通信问题。

生产者与消费者

什么是生产者与消费者？

举例:厨师和服务员。厨师相当于生产者，服务员是消费者。只有当生产者生产东西出来后，消费者才能工作。

整个逻辑是：

前提：一个厨师+一个服务员+一个盘子

1.当厨师在煮菜时，服务员在休息（休眠）只有当煮完菜放到盘子上，服务员（被唤醒）去上菜。

2.当服务员上菜后，由于没有盘子装菜，那么厨师也休息（休眠），只有当服务员上完菜洗干净盘子后，厨师才被唤醒，继续步骤1的操作。

对于这种要求顺序操作的线程，不能用线程锁进行控制，因为我们所学的线程锁都是非公平锁，即是刚解锁的线程很容易反手又抢占回线程锁。
正确的方法应该是在一个线程（被唤醒）执行时，休眠另一个线程

格式：

{
    执行炒菜的程序
    }
this.notifyAll();//唤醒当前在this下睡着的所有线程
try {
    this.wait(); //唤醒以后，厨师厨师线程休眠
} catch (InterruptedException e) {
    e.printStackTrace();
}

public static void main(String[] args) {
    Food f = new Food();
    new Cook(f).start();
    new Waiter(f).start();


}

//厨师
static class Cook extends Thread {
    private Food f;
    public Cook(Food f) {
        this.f = f;
    }

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            if (i % 2 == 0) {
                f.setNameAndSaste("老干妈小米粥", "香辣味");
            } else {
                f.setNameAndSaste("煎饼果子", "甜辣味");
            }
        }
    }
}


//服务生
static class Waiter extends Thread {
    private Food f;

    public Waiter(Food f) {
        this.f = f;
    }

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            try {
                Thread.sleep(100);

            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            f.get();
        }
    }
}

//食物
static class Food  {
    private String name;
    private String taste;

    //true 表示可以生产
    private boolean flag = true;

    //只有厨师对象才会调用这个方法
    public synchronized void setNameAndSaste(String name, String taste) {
        if (flag) {
            this.name = name;
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            this.taste = taste;
            flag = false;
            this.notifyAll();//唤醒当前在this下睡着的所有线程
            try {
                this.wait(); //唤醒以后，厨师厨师线程休眠
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public synchronized void get() {
        if (!flag ) {
            System.out.println("服务员端走的菜d的名称是:" + name + ",味道：" + taste);
            flag = true;//厨师就可以重新做饭了
            this.notifyAll();//唤醒
            try {
                this.wait();//让自己休眠
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

    }
}

线程的六种状态

线程的基本生命周期

带返回值的线程callable

Runnable 与 Callable的对比

接口定义 

//Callable接口 

public interface Callable<V> { 

V call() throws Exception; 

}

//Runnable接口 

public interface Runnable { 

public abstract void run(); 

}

Callable使用步骤

1. 编写类实现Callable接口 , 实现call方法 

class XXX implements Callable<T> { 

@Override 

public <T> call() throws Exception { 

return T; 

} 

} 

2. 创建FutureTask对象 , 并传入第一步编写的Callable类对象 

FutureTask<Integer> future = new FutureTask<>(callable); 

3. 通过Thread,启动线程 

new Thread(future).start();

FutureTask类的方法

public static void main(String[] args) throws ExecutionException, InterruptedException {
    Callable<Integer> c = new MyCallable();//1.创建Callable类型的对象
    FutureTask task = new FutureTask(c);//2.创建任务对象
    new Thread(task).start();//3.启动线程

    //当不调用get方法时，主线程和子线程是同时执行程序，现象为交替打印同样的数字
    //当调用get方法时，只有等get方法执行完（即子线程执行完）后，主线程才继续执行
    Integer j = (Integer) task.get();
    System.out.println("返回值为："+j);
    for (int i=0;i<10;i++){
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(i);
    }

}

static class MyCallable implements Callable<Integer>{

    @Override
    public Integer call() throws Exception {
        //Thread.sleep(3000);
        for (int i=0;i<10;i++){
            Thread.sleep(100);
            System.out.println(i);
        }
        return 100;
    }
}

线程池

线程池：如果并发的线程数量很多，并且每个线程都是执行一个时间很短的任务就结束了，这样频繁创建线程就会大大降低系统的效率，因为频繁创建线程和销毁线程需要时间. 线程池就是一个容纳多个线程的容器，池中的线程可以反复使用，省去了频繁创建线程对象的操作，节省了大量的时间和资源。

原理图

将任务按顺序插入到线程数组的空闲线程
当线程数组内的的线程都为忙碌时，线程将进行排队或者是非定长线程池进行动态扩容。
有些非定长线程池还有清空缓存的功能。例如一个线程在白天动态扩容到800个长度，而晚上只有80个长度被访问，那么空闲的线程将会被清空。

线程池的好处

降低资源消耗。

提高响应速度。

提高线程的可管理性。

Java中的四种线程池

缓存线程池
定长线程池
单线程线程池
周期性任务定长线程池

缓存线程池的实现

缓存线程池.

(长度无限制)
执行流程:
- 1. 判断线程池是否存在空闲线程
    - 1. 存在则使用
    - 1. 不存在,则创建线程并放入线程池, 然后使用

public static void main(String[] args) {
    ExecutorService service = Executors.newCachedThreadPool(); //创建缓存线程池
    //指挥线程池中执行新的任务
    service.execute(new Runnable() {
        @Override
        public void run() {
            System.out.println(Thread.currentThread().getName()+"锄禾日当午");
        }
    });

    service.execute(new Runnable() {
        @Override
        public void run() {
            System.out.println(Thread.currentThread().getName()+"锄禾日当午");
        }
    });

    service.execute(new Runnable() {
        @Override
        public void run() {
            System.out.println(Thread.currentThread().getName()+"锄禾日当午");
        }
    });

    try {
        Thread.sleep(1000);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }

    //由于缓存了1s，有线程空闲了，那么下面这个打印不会创建新的线程池，而是使用空闲的线程池
    service.execute(new Runnable() {
        @Override
        public void run() {
            System.out.println(Thread.currentThread().getName()+"锄禾日当午");
        }
    });

}

定长线程池的实现

定长线程池.

(长度是指定的数值)
执行流程:
- 1.判断线程池是否存在空闲线程
- 2.存在则使用
- 3.不存在空闲线程,且线程池未满的情况下,则创建线程并放入线程池, 然后使用
- 4.不存在空闲线程,且线程池已满的情况下,则等待线程池存在空闲线程

 public static void main(String[] args) {
        ExecutorService service = Executors.newFixedThreadPool(2);
        service.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"锄禾日当午");
                try {
                    Thread.sleep(3000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

            }
        });
        service.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + "锄禾日当午");
                try {
                    Thread.sleep(3000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });

        service.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + "锄禾日当午");
            }
        });
    }

单线程线程池的实现

单线程线程池.

执行流程:

判断线程池的那个线程是否空闲

空闲则使用
不空闲,则等待池中的单个线程空闲后使用

public static void main(String[] args) {
    ExecutorService service = Executors.newSingleThreadExecutor();
    service.execute(new Runnable() {
        @Override
        public void run() {
            System.out.println(Thread.currentThread().getName()+"锄禾日当午");
        }
    });

    service.execute(new Runnable() {
        @Override
        public void run() {
            System.out.println(Thread.currentThread().getName()+"锄禾日当午");
        }
    });

    service.execute(new Runnable() {
        @Override
        public void run() {
            System.out.println(Thread.currentThread().getName()+"锄禾日当午");
        }
    });

    service.execute(new Runnable() {
        @Override
        public void run() {
            System.out.println(Thread.currentThread().getName()+"锄禾日当午");
        }
    });
}

周期性任务定长线程池

周期任务定长线程池.

执行流程:

* 1. 判断线程池是否存在空闲线程

* 2. 存在则使用

* 3. 不存在空闲线程,且线程池未满的情况下,则创建线程并放入线程池, 然后使用

* 4. 不存在空闲线程,且线程池已满的情况下,则等待线程池存在空闲线程

* 周期性任务执行时:

* 定时执行, 当某个时机触发时, 自动执行某任务 .

{
    ScheduledExecutorService service = Executors.newScheduledThreadPool(2);  //1.创建定长
   service.schedule(new Runnable() {   //2.调用线程
        @Override
        public void run() {
            System.out.println("锄禾日当午");
        }
    },5, TimeUnit.SECONDS);*/

    //周期执行
    /**
     * 周期性执行任务
     * 参数1：任务
     * 参数2：延迟时长数字(第一次执行在什么时间以后)
     * 参数3：周期时长数字(每隔多久执行一次)
     * 参数4：时长数字的单位
     */
    service.scheduleAtFixedRate(new Runnable() {
        @Override
        public void run() {
            System.out.println("汗滴禾下土");
        }
    },5,1,TimeUnit.SECONDS);
}

Lambda表达式

格式：函数名称（参数）—>{代码}

public static void main(String[] args) {
    //冗余的Runnable代码
    /*Thread t = new Thread(new Runnable() {
        @Override
        public void run() {
            System.out.println("锄禾日当午");
        }
    });
    t.start();*/

    Thread t = new Thread(() -> {System.out.println("锄禾日当午");}); //lambda表达式
    t.start();

}

码上学习笔记

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
JavaEE笔记——多线程系列

目录线程与进程线程调度同步（线程不安全）与异步（线程安全）并发与并行编写多线程程序ThreadRunnableRunnable与Thread对比的优势设置和获取线程名称线程阻塞线程中断守护线程线程安全问题解决线程安全问题1.同步代码块2.同步方法3.显式锁Lock隐式锁sync和显式锁lock的区别一：出身不同二：使用方式不同三：等待是否可中断四：加锁的时候是否可以公平五：锁绑定多个条件来condition六：从
复制链接

扫一扫