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()方法实现卖票，代码步骤如下@Overridepublic 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;@Overridepublic 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();//使用同一个对象加锁，相当于使用同一把锁@Overridepublic 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();@Overridepublic 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多线程的总结暂时就这些了。