本文简要介绍在 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).回到最初的那个概念,在多线程中,能不需要线程互相通讯就尽量不要用,能不同步就尽量不要使用线程同步,能不使用多线程就尽量不要使用多线程,说得有些含糊,各位自己去参悟吧.