Java中线程总结

本文简要介绍在 Java 世界中， 线程相关知识。主要包含 线程的创建与销毁；线程安全与同步；线程通讯；注意本文没有什么高深新知识，只缘起前段时间在翻看项目代码的时候，发现有些同学对此有诸多误解，故在此稍微整理一下，以帮助类似同学，同时警醒一下自己。

1.  线程的创建和销毁；

a) .创建线程可以通过继承 Thread 类 或 实现 Runnable 接口, 并重写 run() 方法, 其中的run() 方法即是本线程需要执行的内容.

b). 相比于单独继承 Thread ,Runnable接口配合 Thread 实现会更灵活,并可以通过共享一个Runnable接口实例,在Thread中共享资源.

c). 至于线程销毁,不推荐使用 Thread.Stop()方法, 此方法在使用不当情况下会出现死锁,更多的时候推荐在run()方法中使用额外变量(或条件)结束此方法即可.

2. 线程安全与同步;

a). 对于需要遵循ACID原子一致性的代码段, 可以通过 synchronized(lockKey){} 代码块锁定；

b). 同时 synchronized 关键字可以用来修饰一个方法，表示整个方法都需要遵循ACID原子一致性，值得注意的是，此时其实的lockKey等效于this关键字；

b). 在锁定的代码块中推荐再进行一次必要的条件判断。

3. 线程通讯，在java的世界中可以借助 wait() notify() notifyAll() 这三个方法来完成,这三个方法定义在Object类中,因此所有的对象都可以使用.

4.下面通过简单的几个代码片段来加以说明

　　a). 演示线程创建与销毁,及线程安全与同步

 public class ThreadTest implements Runnable {
     private boolean stop;                   //是否需要停止运行
     private int tiketCount = 100000;        //总票数
     private boolean lockTypeIsMethod = true; //是否是提供方法锁定还是代码块

     public boolean isStop() {
         return stop;
     }
     public void setStop(boolean stop) {
         this.stop = stop;
     }

     public boolean isLockTypeMethod() {
         return lockTypeIsMethod;
     }
     public void setLockTypeIsMethod(boolean lockTypeIsMethod) {
         this.lockTypeIsMethod = lockTypeIsMethod;
     }

     @Override
     public void run() {
         while (tiketCount > 0 && !stop) {
             try {
                 Thread.sleep(50);    //延时1秒,方便演示
             } catch (InterruptedException e) {
                 e.printStackTrace();
             }

             //如果是通过锁定方法
             if (lockTypeIsMethod) {
                 sale();
             } else {
                 synchronized (this) {
                     if (tiketCount > 0 && !stop) {
                         System.out.println("使用代码块锁定:threadId="
                                 + Thread.currentThread().getName() + ",ticketNO:" + tiketCount--);
                     }
                 }
             }
         }
     }

     public synchronized void sale() {
         if (tiketCount > 0 && !stop) {
             System.out.println("使用方法锁定:threadId="
                     + Thread.currentThread().getName() + ",ticketNO:" + tiketCount--);
         }
     }
 }

线程定义类

 public static void main(String[] args) throws InterruptedException {
     ThreadTest threadTest = new ThreadTest();   //共享变量ThreadTest
     //启用四个线程
     new Thread(threadTest).start();
     new Thread(threadTest).start();
     new Thread(threadTest).start();
     new Thread(threadTest).start();
     //模拟设置共享变量,
     // 1.交替使用方法体和代码块来进行线程同步实验
     // 2.模拟线程停止
     for (int i = 0; i < 100; i++) {
         Thread.sleep(1000);
         threadTest.setLockTypeIsMethod(i % 2 == 0);
         if (i == 50) {
             threadTest.setStop(true);
         }
     }
 }

调用端

　　b). 演示线程通讯,本处模拟两个线程以生产和消费者角色读写一个集合的示例,其中当集合中有数据的时候通知消费者处理数据,处理完后通知生产者往集合中放入数据

 //数据仓库
 public class DataRepository {
     private List<String> data = new ArrayList<>();
     private boolean hasData;

     public boolean HasData() {
         return hasData;
     }

     public void setHasData(boolean hasData) {
         this.hasData = hasData;
     }

     //放入数据
     public synchronized void put(List<String> data) throws InterruptedException {
         //生产者放入数据的时候,如果还有数据则等待.
         if (hasData) {
             wait();
         }
         this.data = data;
         hasData = true;
         //放入完毕后通知消费者
         notify();
     }

     //读取数据
     public synchronized List<String> get() throws InterruptedException {
         //没有数据则等待
         if (!hasData) {
             wait();
         }
         //获取数据副本返回
         List<String> rs = new ArrayList<>(data);
         data.clear();
         hasData = false;
         notify();
         return rs;
     }
 }

数据仓库

 public class Producer implements  Runnable {
     private DataRepository dataRepository;      //数据仓库
     public Producer(DataRepository dataRepository) {
         this.dataRepository = dataRepository;
     }

     public void run() {
         while (true) {
             try {
                 Thread.sleep(1000);
             } catch (InterruptedException e) {
                 e.printStackTrace();
             }
             List<String> temp = new ArrayList<>();
             temp.add("------------");
             temp.add("第一个数据");
             temp.add("第二个数据");
             temp.add("第三个数据");
             temp.add("第四个数据");
             temp.add("------------");
             try {
                 dataRepository.put(temp);
             } catch (InterruptedException e) {
                 e.printStackTrace();
             }
         }
     }
 }

生产者

 public class Consumer implements Runnable {
     private DataRepository dataRepository;

     public Consumer(DataRepository dataRepository) {
         this.dataRepository = dataRepository;
     }

     public void run() {
         while (true) {
             try {
                 Thread.sleep(1000);
             } catch (InterruptedException e) {
                 e.printStackTrace();
             }
             try {
                 List<String> data=dataRepository.get();
                 if(data!=null&&!data.isEmpty()){
                     for (String temp :data){
                         System.out.println(temp);
                     }
                 }
             } catch (InterruptedException e) {
                 e.printStackTrace();
             }
         }
     }
 }

消费者

 public class Client {
     public static void main(String[] args) throws InterruptedException {

         DataRepository dr=new DataRepository();
         new Thread(new Producer(dr)).start();   //启动生产者线程
         new Thread(new Consumer(dr)).start();   //启动消费者线程
     }
 }

调用端

后记:

　　a). 多线程属于较基础的知识,我们首先需要了解其最基本的概念,才能在项目中游刃有余的应用;

　　b).不管是什么语言,其所需要的理论支持均大同小异;

　　c).回到最初的那个概念,在多线程中,能不需要线程互相通讯就尽量不要用,能不同步就尽量不要使用线程同步,能不使用多线程就尽量不要使用多线程,说得有些含糊,各位自己去参悟吧.