java基础（五）：谈谈java中的多线程

1.多线程

1.1.多线程介绍

　　学习多线程之前，我们先要了解几个关于多线程有关的概念。

　　进程：正在运行的程序。确切的来说，当一个程序进入内存运行，即变成一个进程，进程是处于运行过程中的程序，并且具有一定独立功能，进程是系统进行资源分配和调度的一个独立单位。进程是正在运行的程序，进程负责给程序分配内存空间，而每一个进程都是由程序代码组成的，这些代码在进程中执行的流程就是线程。

　　线程：线程是进程中的一个执行单元，负责当前进程中程序的执行，一个进程中至少有一个线程。一个进程中是可以有多个线程的，这个应用程序也可以称之为多线程程序。

　　简而言之：一个程序运行后至少有一个进程，一个进程中可以包含多个线程，但至少有一个线程。什么是多线程呢？即就是一个程序中有多个线程在同时执行。

1.2.多线程运行原理

　　大部分操作系统都支持多进程并发运行，现在的操作系统几乎都支持同时运行多个任务。比如：现在我们上课一边使用编辑器，一边使用录屏软件，同时还开着画图板，dos窗口等软件。感觉这些软件好像在同时运行着。

　　其实这些软件在某一时刻，只会运行一个进程。这是为什么呢？这是由于CPU(*处理器)在做着高速的切换而导致的。对于CPU而言，它在某个时间点上，只能执行一个程序，即就是说只能运行一个进程，CPU不断地在这些进程之间切换。只是我们自己感觉不到。为什么我们会感觉不到呢?这是因为CPU的执行速度相对我们的感觉实在太快了，虽然CPU在多个进程之间轮换执行，但我们自己感到好像多个进程在同时执行。

　　多线程真的能提高效率吗？其实并不是这样的，因为我们知道，CPU会在多个进程之间做着切换，如果我们开启的程序过多，CPU切换到每一个进程的时间也会变长，我们也会感觉机器运行变慢。所以合理的使用多线程可以提高效率，但是大量使用，并不能给我们带来效率上的提高。

1.3.主线程

　　回想我们以前学习中写过的代码，当我们在dos命令行中输入java空格类名回车后，启动JVM，并且加载对应的class文件。虚拟机并会从main方法开始执行我们的程序代码，一直把main方法的代码执行结束。如果在执行过程遇到循环时间比较长的代码，那么在循环之后的其他代码是不会被执行的。如下代码演示：

 1 class Demo
 2 {
 3     String name;
 4     Demo(String name)
 5     {
 6         this.name = name;
 7     }
 8     void show()
 9     {
10         for (int i=1;i<=20 ;i++ )
11         {
12             System.out.println("name="+name+",i="+i);
13         }
14     }
15 }
16 class ThreadDemo 
17 {
18     public static void main(String[] args) 
19     {
20         Demo d = new Demo("小强");
21         Demo d2 = new Demo("旺财");
22         d.show();        
23         d2.show();
24         System.out.println("Hello World!");
25     }
26 }

　　若在上述代码中show方法中的循环执行次数很多，这时书写在d.show();下面的代码是不会执行的，并且在dos窗口会看到不停的输出name=小强,i=值，这样的语句。为什么会这样呢？

　　原因是：jvm启动后，必然有一个执行路径(线程)从main方法开始的。一直执行到main方法结束。这个线程在java中称之为主线程。当主线程在这个程序中执行时，如果遇到了循环而导致程序在指定位置停留时间过长，无法执行下面的程序。

　　可不可以实现一个主线程负责执行其中一个循环，由另一个线程负责其他代码的执行。实现多部分代码同时执行。这就是多线程技术可以解决的问题。

1.4.如何创建线程

1.4.1.创建线程方式一：继承Thread类

　　该如何创建线程呢？通过API中的英文Thread的搜索，查到Thread类。通过阅读Thread类中的描述。创建新执行线程有两种方法。一种方法是将类声明为 Thread 的子类。该子类应重写 Thread 类的 run 方法。接下来可以分配并启动该子类的实例。

　　创建线程的步骤：

　　1. 定义一个类继承Thread。

　　2. 重写run方法。

　　3. 创建子类对象，就是创建线程对象。

　　4. 调用start方法，开启线程并让线程执行，同时还会告诉jvm去调用run方法。

 1 class Demo extends Thread  //继承Thread
 2 {
 3     String name;
 4     Demo(String name)
 5     {
 6         this.name = name;
 7     }
 8     //复写其中的run方法
 9     public void run()
10     {
11         for (int i=1;i<=20 ;i++ )
12         {
13             System.out.println("name="+name+",i="+i);
14         }
15     }
16 }
17 class ThreadDemo 
18 {
19     public static void main(String[] args) 
20     {
21         //创建两个线程任务
22         Demo d = new Demo("小强");
23         Demo d2 = new Demo("旺财");
24         //d.run(); 这里仍然是主线程在调用run方法，并没有开启两个线程
25         //d2.run();
26         d2.start();//开启一个线程
27         d.run();//主线程在调用run方法
28     }
29 }

　　打印部分结果：由于多线程操作，输出数据会有所不同

　　　　name=旺财,i=1

　　　　name=小强,i=1

　　　　name=旺财,i=2

　　　　name=小强,i=2

　　　　name=小强,i=3

　　　　name=旺财,i=3

　　　　name=旺财,i=4

　　　　name=旺财,i=5

　　　　name=旺财,i=6

　　　　name=旺财,i=7

　　　　..........

　　思考：线程对象调用 run方法和调用start方法区别？

　　线程对象调用run方法不开启线程。仅是对象调用方法。线程对象调用start开启线程，并让jvm调用run方法在开启的线程中执行。

1.4.2.继承Thread类原理

　　为什么要继承Thread类，并调用其的start方法才能开启线程呢？

　　继承Thread类：因为Thread类描述线程事物，具备线程应该有功能。

　　那为什么不直接创建Thread类的对象呢？

1 Thread t1 = new Thread();
2 t1.start();//这样做没有错，但是该start调用的是Thread类中的run方法，而这个run方法没有做什么事情，更重要的是这个run方法中并没有定义我们需要让线程执行的代码。

　　创建线程的目的是什么？

　　是为了建立单独的执行路径，让多部分代码实现同时执行。也就是说线程创建并执行需要给定的代码(线程的任务)。对于之前所讲的主线程，它的任务定义在main函数中。自定义线程需要执行的任务都定义在run方法中。Thread类中的run方法内部的任务并不是我们所需要，只有重写这个run方法，既然Thread类已经定义了线程任务的位置，只要在位置中定义任务代码即可。所以进行了重写run方法动作。

1.5.多线程的内存图解

　　多线程执行时，到底在内存中是如何运行的呢？

　　以上个程序为例，进行图解说明：

　　多线程执行时，在栈内存中，其实每一个执行线程都有一片自己所属的栈内存空间。进行方法的压栈和弹栈。

　　当执行线程的任务结束了，线程自动在栈内存中释放了。但是当所有的执行线程都结束了，那么进程就结束了。

1.6.获取线程名称

　　开启的线程都会有自己的独立运行栈内存，那么这些运行的线程的名字是什么呢？该如何获取呢？既然是线程的名字，按照面向对象的特点，是哪个对象的属性和谁的功能，那么我们就去找那个对象就可以了。查阅Thread类的API文档发现有个方法是获取当前正在运行的线程对象。还有个方法是获取当前线程对象的名称。既然找到了，我们就可以试试。

　　　　Thread.currentThread()获取当前线程对象

　　　　Thread.currentThread().getName();获取当前线程对象的名称

 1 class Demo extends Thread  //继承Thread
 2 {
 3     String name;
 4     Demo(String name)
 5     {
 6         this.name = name;
 7     }
 8     //复写其中的run方法
 9     public void run()
10     {
11         for (int i=1;i<=20 ;i++ )
12         {
13             System.out.println("name="+name+","+Thread.currentThread().getName()+",i="+i);
14         }
15     }
16 }
17 class ThreadDemo 
18 {
19     public static void main(String[] args) 
20     {
21         //创建两个线程任务
22         Demo d = new Demo("小强");
23         Demo d2 = new Demo("旺财");
24         d2.start();//开启一个线程
25         d.run();//主线程在调用run方法
26     }
27 }

原来主线程的名称： main

自定义的线程： Thread-0 线程多个时，数字顺延。Thread-1......

进行多线程编程时不要忘记了Java程序运行时从主线程开始，main方法的方法体就是主线程的线程执行体。

1.7.创建线程的第二种方式

　　掌握了如何创建线程对象，以及开启线程后，记得在查阅API时，还说了有第二种开启线程的方式，那么第二种是什么呢？

1.7.1.实现Runnable接口

　　继续查看API发现，创建线程的另一种方法是声明实现 Runnable 接口的类。该类然后实现 run 方法。然后可以分配该类的实例，在创建 Thread 时作为一个参数来传递并启动。

　　怎么还要实现Runnable接口，Runable是啥玩意呢？继续API搜索。

　　查看Runnable接口说明文档：Runnable 接口应该由那些打算通过某一线程执行其实例的类来实现。类必须定义一个称为 run 的无参数方法。

　　总结：

　　创建线程的第二种方式：实现Runnable接口。

　　 1、定义类实现Runnable接口。

　　 2、覆盖接口中的run方法。。

　　 3、创建Thread类的对象

　　 4、将Runnable接口的子类对象作为参数传递给Thread类的构造函数。

　　 5、调用Thread类的start方法开启线程。

 1 代码演示：
 2 class Demo implements Runnable
 3 {
 4     private String name;
 5     Demo(String name)
 6     {
 7         this.name = name;
 8     }
 9     //覆盖了接口Runnable中的run方法。
10     public void run()
11     {
12         for(int i=1; i<=20; i++)
13         {            System.out.println("name="+name+"..."+Thread.currentThread().getName()+"..."+i);
14         }
15     }
16 }
17 class ThreadDemo2 
18 {
19     public static void main(String[] args) 
20     {
21         //创建Runnable子类的对象。注意它并不是线程对象。
22         Demo d = new Demo("Demo");
23         //创建Thread类的对象，将Runnable接口的子类对象作为参数传递给Thread类的构造函数。
24         Thread t1 = new Thread(d);
25         Thread t2 = new Thread(d);
26         //将线程启动。
27         t1.start();
28         t2.start();
29         System.out.println(Thread.currentThread().getName()+"----->");
30         System.out.println("Hello World!");
31     }
32 }

　　输出结果：

1.7.2.实现Runnable的原理

　　为什么需要定一个类去实现Runnable接口呢？继承Thread类和实现Runnable接口有啥区别呢？

　　实现Runnable接口，避免了继承Thread类的单继承局限性。覆盖Runnable接口中的run方法，将线程任务代码定义到run方法中。创建Thread类的对象，只有创建Thread类的对象才可以创建线程。线程任务已被封装到Runnable接口的run方法中，而这个run方法所属于Runnable接口的子类对象，所以将这个子类对象作为参数传递给Thread的构造函数，这样，线程对象创建时就可以明确要运行的线程的任务。

1.7.3.实现Runnable的好处

　　第二种方式实现Runnable接口避免了单继承的局限性，所以较为常用。实现Runnable接口的方式，更加的符合面向对象，线程分为两部分，一部分线程对象，一部分线程任务。继承Thread类，线程对象和线程任务耦合在一起。一旦创建Thread类的子类对象，既是线程对象，有又有线程任务。实现runnable接口，将线程任务单独分离出来封装成对象，类型就是Runnable接口类型。Runnable接口对线程对象和线程任务进行解耦。

1.8.线程状态图

　　查阅API关于IllegalThreadStateException这个异常说明信息发现，这个异常的描述信息为：指示线程没有处于请求操作所要求的适当状态时抛出的异常。这里面说适当的状态，啥意思呢？难道是说线程还有状态吗？

　　1、新建（new）：线程对象被创建后就进入了新建状态。如：Thread thread = new Thread();　　

　　2、就绪状态（Runnable）：也被称为“可执行状态”。线程对象被创建后，其他线程调用了该对象的start()方法，从而启动该线程。如：thread.start(); 处于就绪状态的线程随时可能被CPU调度执行。

　　3、运行状态（Running）：线程获取CPU权限进行执行。需要注意的是，线程只能从就绪状态进入到运行状态。

　　4、阻塞状态（Blocked）：阻塞状态是线程因为某种原因放弃CPU使用权限，暂时停止运行。直到线程进入就绪状态，才有机会进入运行状态。阻塞的三种情况：

　　　　 1）等待阻塞：通过调用线程的wait()方法，让线程等待某工作的完成。

　　　　 2）同步阻塞：线程在获取synchronized同步锁失败（因为锁被其他线程占用），它会进入同步阻塞状态。

　　　　3）其他阻塞：通过调用线程的sleep()或join()或发出了I/O请求时，线程会进入到阻塞状态。当sleep()状态超时、join()等待线程终止或超时、或者I/O处理完毕时，线程重新转入就绪状态。

　　5、死亡状态（Dead）：线程执行完了或因异常退出了run()方法，该线程结束生命周期。

1.9.线程的安全问题

　　带女朋友看电影，需要买票，电影院要卖票，模拟电影院的买票操作

　　假设我们想要的电影是 “功夫熊猫3”，本次电影的座位共100个(本厂电影只能卖100张票)

　　模拟电影院的售票窗口，实现多个窗口同时卖 “功夫熊猫3”这场电影票(多个窗口一起卖这100张票)

　　需要窗口：采用线程对象

　　需要票：Runnable接口子类来模拟

 1 public class ThreadDemo {
 2     public static void main(String[] args) {
 3         //创建票对象
 4         Ticket ticket = new Ticket();
 5         
 6         //创建3个窗口
 7         Thread t1  = new Thread(ticket, "窗口1");
 8         Thread t2  = new Thread(ticket, "窗口2");
 9         Thread t3  = new Thread(ticket, "窗口3");
10         
11         t1.start();
12         t2.start();
13         t3.start();
14     }
15 }
16 
17 public class Ticket implements Runnable {
18     //共100票
19     int ticket = 100;
20 
21     @Override
22     public void run() {
23         //模拟卖票
24         while(true){
25             //t1,t2,t3
26             if (ticket > 0) {
27                 //模拟选坐的操作
28                 try {
29                     Thread.sleep(1);
30                 } catch (InterruptedException e) {
31                     e.printStackTrace();
32                 }
33                 System.out.println(Thread.currentThread().getName() + "正在卖票:" + ticket--);
34             }
35         }
36     }
37 }

　　总结：上面程序出新了问题

　　票出现了重复的票

　　错误的票 0

1.10.同步的锁

　　同步代码块: 在代码块声明上加上synchronized

1 synchronized (锁对象) {
2     可能会产生线程安全问题的代码
3 }

　　同步代码块中的锁对象可以是任意的对象，多个线程对象使用的是同一个锁对象

　　把Ticket.java进行了代码修改

 1 public class Ticket implements Runnable {
 2     //共100票
 3     int ticket = 100;
 4     
 5     //定义所对象
 6     Object lock = new Object();
 7     @Override
 8     public void run() {
 9         //模拟卖票
10         while(true){
11             //同步代码块
12             synchronized (lock){
13                 if (ticket > 0) {
14                     //模拟选坐的操作
15                     try {
16                         Thread.sleep(10);
17                     } catch (InterruptedException e) {
18                         e.printStackTrace();
19                     }
20                     System.out.println(Thread.currentThread().getName() + "正在卖票:" + ticket--);
21                 }
22             }
23         }
24     }
25 }

　　当使用了同步代码块后，上述的线程的安全问题，解决了。

　　同步方法：在方法声明上加上synchronized

1 public synchronized void method(){
2 
3     可能会产生线程安全问题的代码
4 
5 }

　　同步方法中的锁对象是 this

 1 //同步方法,锁对象this
 2     public synchronized void method(){
 3         //this.name = name;
 4         if (ticket > 0) {
 5             //模拟选坐的操作
 6             try {
 7                 Thread.sleep(10);
 8             } catch (InterruptedException e) {
 9                 e.printStackTrace();
10             }
11             System.out.println(Thread.currentThread().getName() + "正在卖票:" + ticket--);
12         }
13     }

　　静态同步方法: 在方法声明上加上synchronized

1 public static synchronized void method(){
2 可能会产生线程安全问题的代码
3 }

1.11.死锁

　　同步锁的另一个弊端：当线程任务中出现了多个同步(多个锁)时，如果同步中嵌套了其他的同步。这时容易引发一种现象：死锁。这种情况能避免就避免掉。

1 synchronzied(A锁){
2     synchronized(B锁){
3          
4 }
5 }

 1 /*
 2  * 定义锁对象
 3  */
 4 public class MyLock {
 5     public static final Object lockA = new Object();
 6     public static final Object lockB = new Object();
 7 }
 8 
 9 /*
10  * 线程任务类
11  */
12 public class ThreadTask implements Runnable {
13 
14     int x = new Random().nextInt(1);//0,1    
15     
16     //指定线程要执行的任务代码
17     @Override
18     public void run() {
19         while(true){
20             if (x%2 ==0) {
21                 //情况一
22                 synchronized (MyLock.lockA) {
23                     System.out.println("if-LockA");
24                     synchronized (MyLock.lockB) {
25                         System.out.println("if-LockB");
26                         System.out.println("if大口吃肉");
27                     }
28                 }
29             } else {
30                 //情况二
31                 synchronized (MyLock.lockB) {
32                     System.out.println("else-LockB");
33                     synchronized (MyLock.lockA) {
34                         System.out.println("else-LockA");
35                         System.out.println("else大口吃肉");
36                     }
37                 }
38             }
39             x++;
40         }
41     }
42 }
43 
44 public class ThreadDemo {
45     public static void main(String[] args) {
46         //创建线程任务类对象
47         ThreadTask task = new ThreadTask();
48         
49         //创建两个线程
50         Thread t1 = new Thread(task);
51         Thread t2 = new Thread(task);
52         
53         //启动线程
54         t1.start();
55         t2.start();
56     }
57 }

1.12.Lock接口

　　查阅API，发现Lock接口，比同步更厉害，有更多操作；

　　 lock():获取锁

　　 unlock():释放锁；

　　提供了一个更加面对对象的锁，在该锁中提供了更多的显示的锁操作。使用Lock接口，以及其中的lock()方法和unlock()方法替代同步。

　　如下代码演示：

 1 public class Ticket implements Runnable {
 2     //共100票
 3     int ticket = 100;
 4     
 5     //创建Lock锁对象
 6     Lock ck = new ReentrantLock();
 7     
 8     @Override
 9     public void run() {
10         //模拟卖票
11         while(true){
12             //synchronized (lock){
13             ck.lock();
14                 if (ticket > 0) {
15                     //模拟选坐的操作
16                     try {
17                         Thread.sleep(10);
18                     } catch (InterruptedException e) {
19                         e.printStackTrace();
20                     }
21                     System.out.println(Thread.currentThread().getName() + "正在卖票:" + ticket--);
22                 }
23             ck.unlock();
24             //}
25         }
26     }
27 }

1.13.线程的匿名内部类的使用

 1 方式1
 2         new Thread() {
 3             public void run() {
 4                 for (int x = 0; x < 40; x++) {
 5                     System.out.println(Thread.currentThread().getName()
 6                             + "...X...." + x);
 7                 }
 8             }
 9         }.start();
10 
11 方式2
12         Runnable r = new Runnable() {
13             public void run() {
14                 for (int x = 0; x < 40; x++) {
15                     System.out.println(Thread.currentThread().getName()
16                             + "...Y...." + x);
17                 }
18             }
19         };
20         new Thread(r).start();

2.多线程文件上传

　　实现服务器端可以同时接收多个客户端上传的文件。我们要修改服务器端代码

 1 /*
 2  * 文件上传  服务器端
 3  *
 4  */
 5 public class TCPServer {
 6     public static void main(String[] args) throws IOException {
 7         //1,创建服务器，等待客户端连接
 8         ServerSocket serverSocket = new ServerSocket(6666);
 9         
10         //实现多个客户端连接服务器的操作
11         while(true){
12             final Socket clientSocket = serverSocket.accept();
13             //启动线程，完成与当前客户端的数据交互过程
14             new Thread(){
15                 public void run() {
16                     try{
17                         //显示哪个客户端Socket连接上了服务器
18                         InetAddress ipObject = clientSocket.getInetAddress();//得到IP地址对象
19                         String ip = ipObject.getHostAddress(); //得到IP地址字符串
20                         System.out.println("小样，抓到你了，连接我！！" + "IP:" + ip);
21                         
22                         //7,获取Socket的输入流
23                         InputStream in = clientSocket.getInputStream();
24                         //8,创建目的地的字节输出流   D:\\upload\\192.168.74.58(1).jpg
25                         BufferedOutputStream fileOut = new BufferedOutputStream(new FileOutputStream("D:\\upload\\"+ip+"("+System.currentTimeMillis()+").jpg"));
26                         //9,把Socket输入流中的数据，写入目的地的字节输出流中
27                         byte[] buffer = new byte[1024];
28                         int len = -1;
29                         while((len = in.read(buffer)) != -1){
30                             //写入目的地的字节输出流中
31                             fileOut.write(buffer, 0, len);
32                         }
33                         
34                         //-----------------反馈信息---------------------
35                         //10,获取Socket的输出流, 作用：写反馈信息给客户端
36                         OutputStream out = clientSocket.getOutputStream();
37                         //11,写反馈信息给客户端
38                         out.write("图片上传成功".getBytes());
39                         
40                         out.close();
41                         fileOut.close();
42                         in.close();
43                         clientSocket.close();
44                     } catch(IOException e){
45                         e.printStackTrace();
46                     }
47                 };
48             }.start();
49         }
50 
51         //serverSocket.close();
52     }
53 }

3.总结

　　创建线程的方式

　　方式1，继承Thread线程类

　　步骤

　　　　1，自定义类继承Thread类

　　　　2，在自定义类中重写Thread类的run方法

　　　　3，创建自定义类对象(线程对象)

　　　　4，调用start方法，启动线程，通过JVM，调用线程中的run方法

　　方式2，实现Runnable接口

　　步骤

　　　　1，创建线程任务类实现Runnable接口

　　　　2，在线程任务类中重写接口中的run方法

　　　　3，创建线程任务类对象

　　　　4，创建线程对象，把线程任务类对象作为Thread类构造方法的参数使用

　　　　5，调用start方法，启动线程，通过JVM，调用线程任务类中的run方法

　　同步锁

　　多个线程想保证线程安全，必须要使用同一个锁对象

A.同步代码块

1  synchronized (锁对象){
2     可能产生线程安全问题的代码
3 }

同步代码块的锁对象可以是任意的对象

B.同步方法

1   public synchronized void method()
2               可能产生线程安全问题的代码
3 }

同步方法中的锁对象是 this

C.静态同步方法

1 public synchronized void method()
2               可能产生线程安全问题的代码
3 }

静态同步方法中的锁对象是类名.class

参考：

java编程思想

黑马教学视频

https://www.cnblogs.com/huangzhe1515023110/p/9276097.html

秒客网