一：线程安全与线程不安全

https://blog.csdn.net/m0_37450089/article/details/78761522

当我们查看JDK API的时候，总会发现一些类说明写着，线程安全或者线程不安全，比如说StringBuilder中，有这么一句，“将StringBuilder 的实例用于多个线程是不安全的。如果需要这样的同步，则建议使用StringBuffer。 ”，那么下面手动创建一个线程不安全的类，然后在多线程中使用这个类，看看有什么效果。

        Count.java：

1. public class Count {  
2.     private int num;  
3.     public void count() {  
4.         for(int i = 1; i <= 10; i++) {  
5.             num += i;  
6.         }  
7.         System.out.println(Thread.currentThread().getName() + "-" + num);  
8.     }  
9. }  

        在这个类中的count方法是计算1一直加到10的和，并输出当前线程名和总和，我们期望的是每个线程都会输出55。

 

        ThreadTest.java：

 

1. public class ThreadTest {  
2.     public static void main(String[] args) {  
3.         Runnable runnable = new Runnable() {  
4.             Count count = new Count();  
5.             public void run() {  
6.                 count.count();  
7.             }  
8.         };  
9.         for(int i = 0; i < 10; i++) {  
10.             new Thread(runnable).start();  
11.         }  
12.     }  
13. }  

        这里启动了10个线程，看一下输出结果：

 

1. Thread-0-55  
2. Thread-1-110  
3. Thread-2-165  
4. Thread-4-220  
5. Thread-5-275  
6. Thread-6-330  
7. Thread-3-385  
8. Thread-7-440  
9. Thread-8-495  
10. Thread-9-550  

        只有Thread-0线程输出的结果是我们期望的，而输出的是每次都累加的，这里累加的原因以后的博文会说明，那么要想得到我们期望的结果，有几种解决方案：

 

        1. 将Count中num变成count方法的局部变量；

 

1. public class Count {  
2.     public void count() {  
3.         int num = 0;  
4.         for(int i = 1; i <= 10; i++) {  
5.             num += i;  
6.         }  
7.         System.out.println(Thread.currentThread().getName() + "-" + num);  
8.     }  
9. }  

        2. 将线程类成员变量拿到run方法中，这时count引用是线程内的局部变量；

 

1. public class ThreadTest4 {  
2.     public static void main(String[] args) {  
3.         Runnable runnable = new Runnable() {  
4.             public void run() {  
5.                 Count count = new Count();  
6.                 count.count();  
7.             }  
8.         };  
9.         for(int i = 0; i < 10; i++) {  
10.             new Thread(runnable).start();  
11.         }  
12.     }  
13. }   

        3. 每次启动一个线程使用不同的线程类，不推荐。

        上述测试，我们发现，存在成员变量的类用于多线程时是不安全的，不安全体现在这个成员变量可能发生非原子性的操作，而变量定义在方法内也就是局部变量是线程安全的。想想在使用struts1时，不推荐创建成员变量，因为action是单例的，如果创建了成员变量，就会存在线程不安全的隐患，而struts2是每一次请求都会创建一个action，就不用考虑线程安全的问题。所以，日常开发中，通常需要考虑成员变量或者说全局变量在多线程环境下，是否会引发一些问题。

多线程实现方法：1：继承Thread类

创建好了自己的线程类之后，就可以创建线程对象了，然后通过start()方法去启动线程。注意，不是调用run()方法启动线程，run方法中只是定义需要执行的任务，如果调用run方法，即相当于在主线程中执行run方法，跟普通的方法调用没有任何区别，此时并不会创建一个新的线程来执行定义的任务。

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

public class Test {     public static void main(String[] args)  {         MyThread thread = new MyThread();         thread.start();     } } class MyThread extends Thread{     private static int num = 0;     public MyThread(){         num++;     }     @Override     public void run() {         System.out.println("主动创建的第"+num+"个线程");     } }

在上面代码中，通过调用start()方法，就会创建一个新的线程了。为了分清start()方法调用和run()方法调用的区别，请看下面一个例子：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22

public class Test {     public static void main(String[] args)  {         System.out.println("主线程ID:"+Thread.currentThread().getId());         MyThread thread1 = new MyThread("thread1");         thread1.start();         MyThread thread2 = new MyThread("thread2");         thread2.run();     } }   class MyThread extends Thread{     private String name;       public MyThread(String name){         this.name = name;     }       @Override     public void run() {         System.out.println("name:"+name+" 子线程ID:"+Thread.currentThread().getId());     } }

运行结果：

 

从输出结果可以得出以下结论：

1）thread1和thread2的线程ID不同，thread2和主线程ID相同，说明通过run方法调用并不会创建新的线程，而是在主线程中直接运行run方法，跟普通的方法调用没有任何区别；

2）虽然thread1的start方法调用在thread2的run方法前面调用，但是先输出的是thread2的run方法调用的相关信息，说明新线程创建的过程不会阻塞主线程的后续执行。

 

2：实现Runnable接口

在Java中创建线程除了继承Thread类之外，还可以通过实现Runnable接口来实现类似的功能。实现Runnable接口必须重写其run方法。
下面是一个例子：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

public class Test {     public static void main(String[] args)  {         System.out.println("主线程ID："+Thread.currentThread().getId());         MyRunnable runnable = new MyRunnable();         Thread thread = new Thread(runnable);         thread.start();     } } class MyRunnable implements Runnable{     public MyRunnable() {     }       @Override     public void run() {         System.out.println("子线程ID："+Thread.currentThread().getId());     } }

Runnable的中文意思是“任务”，顾名思义，通过实现Runnable接口，我们定义了一个子任务，然后将子任务交由Thread去执行。注意，这种方式必须将Runnable作为Thread类的参数，然后通过Thread的start方法来创建一个新线程来执行该子任务。如果调用Runnable的run方法的话，是不会创建新线程的，这根普通的方法调用没有任何区别。

事实上，查看Thread类的实现源代码会发现Thread类是实现了Runnable接口的。

在Java中，这2种方式都可以用来创建线程去执行子任务，具体选择哪一种方式要看自己的需求。直接继承Thread类的话，可能比实现Runnable接口看起来更加简洁，但是由于Java只允许单继承，所以如果自定义类需要继承其他类，则只能选择实现Runnable接口。

 

创建多线程的两种方式，一种直接创建，一种放runable对象作为target去创建，一般使用第二种，比较有面向对象的思想在其中；查看Thread的实现类可以看到，如果执行的线程类重写了run方法，覆盖了run方法，那就用自己的，没有覆盖，那就用Thread类得，就会去找runable类；

 注：多线程并不会提高程序的效率，有可能还会降低！但是多线程能充分利用cpu的资源

注：本文装载自 https://blog.csdn.net/z69183787/article/details/28644113