Java——多线程学习
参考文章：https://www.jb51.net/article/127443.htm
1、先来说下多线程的概念：
- 多线程：一个进程如果有多条执行路径，则称为多线程程序。
简单来说就是原来是一条路径执行（只有一个CPU的情况下），现在是多条路径执行。就相当于一条公路，原来是一条路，为提高使用效率，充分使用这条道路，在路中间加了一些线，变成了多车道(仍是单向的)。
2、多线程的优点：
- 资源利用率更高
- 程序设计在某些情况下更简单
- 程序响应更快
1、关于资源利用率更高：
- 假如一个应用程序需要从磁盘中读取和处理文件。从磁盘读取一个文件需要5秒，处理一个文件需要2秒。那么处理这样的两个文件则需要
5秒读取文件A
2秒处理文件A
5秒读取文件B
2秒处理文件B
---------------------
总共需要14秒
- 从磁盘中读取文件的时候，大部分的CPU时间用于等待磁盘去读取数据。在这段时间里CPU处于空闲状态。它可以做一些别的事情。通过改变操作的顺序，就能够更好的使用CPU资源。看下面的顺序：
5秒读取文件A
5秒读取文件B + 2秒处理文件A
2秒处理文件B
---------------------
总共需要12秒
- CPU等待第一个文件被读取完。然后开始读取第二个文件。当第二文件在被读取的时候（IO读取，CPU处于空闲），CPU会去处理第一个文件。在等待磁盘读取文件的时候，CPU大部分时间是空闲的。
总的说来，CPU能够在等待IO的时候做一些其他的事情。这个不一定就是磁盘IO。它也可以是网络的IO，或者用户输入。通常情况下，网络和磁盘的IO比内存的IO慢的多。
2、程序设计更简单：
- 在单线程应用程序中，如果你想编写程序手动处理上面所提到的读取和处理的顺序，你必须记录每个文件读取和处理的状态。
- 相反，你可以启动两个线程，每个线程分别运行一个文件的读取和处理。线程会在等待磁盘读取文件的过程中被阻塞。在等待的时候，其他的线程能够使用CPU去处理已经读取完的文件。
- 其结果就是，磁盘总是在繁忙地读取不同的文件到内存中。这会带来磁盘和CPU利用率的提升。而且每个线程只需要记录一个文件，因此这种方式也很容易编程实现。
3、 程序响应更快：
- 如果一个请求需要占用大量的时间来处理，在这段时间内客户端就无法发送新的请求给服务端。只有服务器在监听的时候，请求才能被接收。
- 另一种设计是，监听线程把请求传递给工作者线程(worker thread)，然后立刻返回去监听。而工作者线程则能够处理这个请求并发送一个回复给客户端。
- 这样就大大提高了程序的响应速度。
以下是一个多线程实现买票的例子：
1、案例需求：
- 某电影院目前正在上映国产大片，共有100张票，而它有3个窗口卖票，请设计一个程序模拟该电影院卖票。
实现步骤：
- 定义一个类SellTicket实现Runnable接口，里面定义一个成员变量：private int tickets = 100;
- 在SellTicket类中重写run()方法实现卖票，代码步骤如下
- 判断票数大于0，就卖票，并告知是哪个窗口卖的
- 卖了票之后，总票数要减1
- 票没有了，也可能有人来问，所以这里用死循环让卖票的动作一直执行
- 定义一个测试类SellTicketDemo，里面有main方法，代码步骤如下
- 创建SellTicket类的对象
- 创建三个Thread类的对象，把SellTicket对象作为构造方法的参数，并给出对应的窗口名称
- 启动线程
代码实现：
public class SellTicket implements Runnable {
private int tickets = 100;
//在SellTicket类中重写run()方法实现卖票，代码步骤如下
@Override
public void run() {
while (true) {
if (tickets > 0) {
System.out.println(Thread.currentThread().getName() + "正在出售第" +tickets + "张票");
tickets--;
}
}
}
}
public class SellTicketDemo {
public static void main(String[] args) {
//创建SellTicket类的对象
SellTicket st = new SellTicket();
//创建三个Thread类的对象，把SellTicket对象作为构造方法的参数，并给出对应的窗口名称
Thread t1 = new Thread(st,"窗口1");
Thread t2 = new Thread(st,"窗口2");
Thread t3 = new Thread(st,"窗口3");
//启动线程
t1.start();
t2.start();
t3.start();
}
}
执行结果：
可以看到票数出现了异常，出现了重复的票，甚至还有可能出现负数的票。
2、卖票案例的问题：
问题产生原因：
- 线程执行的随机性导致的
详细解析：
相同的票出现了多次:
public class SellTicket implements Runnable {
private int tickets = 100;
@Override
public void run() {
while (true) {
//tickets = 100;
//t1,t2,t3
//假设t1线程抢到CPU的执行权
if (tickets > 0) {
//通过sleep()方法来模拟出票时间
try {
Thread.sleep(100);
//t1线程休息100毫秒
//t2线程抢到了CPU的执行权，t2线程就开始执行，执行到这里的时候，t2线程休息100毫秒
//t3线程抢到了CPU的执行权，t3线程就开始执行，执行到这里的时候，t3线程休息100毫秒
} catch (InterruptedException e) {
e.printStackTrace();
}
//假设线程按照顺序醒过来
//t1抢到CPU的执行权，在控制台输出：窗口1正在出售第100张票
System.out.println(Thread.currentThread().getName() + "正在出售第"+tickets + "张票");
//t2抢到CPU的执行权，在控制台输出：窗口2正在出售第100张票
//t3抢到CPU的执行权，在控制台输出：窗口3正在出售第100张票
tickets--;
//如果这三个线程还是按照顺序来，这里就执行了3次--的操作，最终票就变成了97
}
}
}
}
出现了负数的票：
public class SellTicket implements Runnable {
private int tickets = 100;
public void run() {
while (true) {
//tickets = 1;
//t1,t2,t3
//假设t1线程抢到CPU的执行权
if (tickets > 0) {
//通过sleep()方法来模拟出票时间
try {
Thread.sleep(100);
//t1线程休息100毫秒
//t2线程抢到了CPU的执行权，t2线程就开始执行，执行到这里的时候，t2线程休息100毫秒
//t3线程抢到了CPU的执行权，t3线程就开始执行，执行到这里的时候，t3线程休息100毫秒
} catch (InterruptedException e) {
e.printStackTrace();
}
//假设线程按照顺序醒过来
//t1抢到了CPU的执行权，在控制台输出：窗口1正在出售第1张票
//假设t1继续拥有CPU的执行权，就会执行tickets--;操作，tickets = 0;
//t2抢到了CPU的执行权，在控制台输出：窗口1正在出售第0张票
//假设t2继续拥有CPU的执行权，就会执行tickets--;操作，tickets = -1;
//t3抢到了CPU的执行权，在控制台输出：窗口3正在出售第-1张票
//假设t2继续拥有CPU的执行权，就会执行tickets--;操作，tickets = -2;
System.out.println(Thread.currentThread().getName() + "正在出售第" +tickets + "张票");
tickets--;
}
}
}
}
3、同步代码块解决数据安全问题：
安全问题出现的条件：
- 是多线程环境
- 有共享数据
- 有多条语句操作共享数据
如何解决多线程安全问题呢?
- 基本思想：让程序没有安全问题的环境
如何实现?
- 把多条语句操作共享数据的代码给锁起来，让任意时刻只能有一个线程执行即可。
Java提供了同步代码块的方式来解决：
同步代码块格式：
synchronized(任意对象) {
多条语句操作共享数据的代码
}
synchronized(任意对象)：就相当于给代码加锁了，任意对象就可以看成是一把锁。
同步的好处和弊端：
- 好处：解决了多线程的数据安全问题
- 弊端：当线程很多时，因为每个线程都会去判断同步上的锁，这是很耗费资源的，无形中会降低程序的运行效率。
代码演示：
package sellticket;
public class SellTicket implements Runnable {
private int tickets = 100;
private Object obj = new Object();//使用同一个对象加锁，相当于使用同一把锁
@Override
public void run() {
while (true) {
//tickets = 100;
//t1,t2,t3
//假设t1抢到了CPU的执行权
//假设t2抢到了CPU的执行权
synchronized (obj) {
//t1进来后，就会把这段代码给锁起来
if (tickets > 0) {
try {
Thread.sleep(100);
//t1休息100毫秒
} catch (InterruptedException e) {
e.printStackTrace();
}
//窗口1正在出售第100张票
System.out.println(Thread.currentThread().getName() + "正在出售第" + tickets + " 张票");
tickets--; //tickets = 99;
}
}
//t1出来了，这段代码的锁就被释放了
}
}
}
public class SellTicketDemo {
public static void main(String[] args) {
SellTicket st = new SellTicket();
Thread t1 = new Thread(st, "窗口1");
Thread t2 = new Thread(st, "窗口2");
Thread t3 = new Thread(st, "窗口3");
t1.start();
t2.start();
t3.start();
}
}
4、同步方法解决数据安全问题：
同步方法：就是把synchronized关键字加到方法上。
修饰符 synchronized 返回值类型 方法名(方法参数) {
方法体；
}
同步方法的锁对象是：this
静态同步方法：
- 同步静态方法：就是把synchronized关键字加到静态方法上
例：
同步方法:
private synchronized void sellTicket() {
if (tickets > 0) {
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "正在出售第" + tickets + "张票");
tickets--;
}
}
静态同步方法:
private static synchronized void sellTicket() {
if (tickets > 0) {
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "正在出售第" +tickets + "张票");
tickets--;
}
}
}
5、Lock锁：
虽然我们可以理解同步代码块和同步方法的锁对象问题，但是我们并没有直接看到在哪里加上了锁，在哪里释放了锁，为了更清晰的表达如何加锁和释放锁，JDK5以后提供了一个新的锁对象Lock
- Lock是接口不能直接实例化，采用它的实现类ReentrantLock来实例化。
ReentrantLock构造方法：
加锁解锁方法：
例：
public class SellTicket implements Runnable {
private int tickets = 100;
private Lock lock = new ReentrantLock();
@Override
public void run() {
while (true) {
try {
lock.lock();
if (tickets > 0) {
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "正在出售第" + tickets + " 张票");
tickets--;
}
} finally {
lock.unlock();
}
}
}
}
关于java多线程的总结暂时就这些了。
