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);    //延时,方便演示
            } 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).回到最初的那个概念,在多线程中,能不需要线程互相通讯就尽量不要用,能不同步就尽量不要使用线程同步,能不使用多线程就尽量不要使用多线程,说得有些含糊,各位自己去参悟吧.