面试必会之多线程之间实现通讯

1、什么是多线程之间通讯？

多线程之间通讯，其实就是多个线程在操作同一个资源，但是操作的动作不同。

2、多线程之间通讯需求

需求:第一个线程写入(input)用户，另一个线程取读取(out)用户，实现写一个，读一个的操作。

代码演示如下：

共享资源实体类

class Res {
    public String userSex;
    public String userName;
}

输入线程资源

class InpThread extends Thread {
	private Res res;

	public InpThrad(Res res) {
            this.res = res;
	}

	@Override
	public void run() {
            int count = 0;
            while (true) {
		if (count == 0) {
		    res.userName = "小明";
		    res.userSex = "男";
		} else {
		    res.userName = "小红";
		    res.userSex = "女";
		}
		count = (count + 1) % 2;
	    }
	}
}

输出线程

class OutThread extends Thread {
	private Res res;

	public OutThread(Res res) {
	    this.res = res;
	}

	@Override
	public void run() {
            while (true) {
                System.out.println(res.userName + "--" + res.userSex);
	      }
	}
}

运行代码

public static void main(String[] args) {
        Res res = new Res();
	InpThrad inpThrad = new InpThrad(res);
	OutThread outThread = new OutThread(res);
	intThrad.start();
	outThread.start();
}

运行结果

注意：此时数据会发生错乱，造成线程安全问题

那么解决好线程安全问题，运行结果又会是怎样的呢？

在输入线程InpThread 类中加上synchronized

class InpThread extends Thread {
	private Res res;

	public InpThrad(Res res) {
		this.res = res;
	}

	@Override
	public void run() {
            int count = 0;
	    while (true) {
		synchronized (res) {
		if (count == 0) {
		    res.userName = "小明";
		    res.userSex = "男";
		} else {
		    res.userName = "小红";
		    res.userSex = "女";
		}
		count = (count + 1) % 2;
	        }
	    }
        }
}

在输出线程OutThread类中也加上synchronized

class OutThread extends Thread {
	private Res res;

	public OutThread(Res res) {
		this.res = res;
	}

	@Override
	public void run() {
            while (true) {
	        synchronized (res) {
		    System.out.println(res.userName + "--" + res.userSex);
		}
	    }
	}
}

那么此时的运行结果是怎样的呢？

注意：InpThread 和 OutThread两个线程同时并行进行，在OutThread线程获取到CPU时会进行多次打印，并不会实现依次打印的效果

那么怎样才能实现依次打印这种效果呢？

3、wait()、notify()、notifyAll()方法

wait()、notify()、notifyAll()是三个定义在Object类里的方法，可以用来控制线程的状态。

如果对象调用了wait方法就会使持有该对象的线程把该对象的控制权交出去，然后处于等待状态。
如果对象调用了notify方法就会通知某个正在等待这个对象的控制权的线程可以继续运行。
如果对象调用了notifyAll方法就会通知所有等待这个对象控制权的线程继续运行。

使用这三个方法就可以实现线程之间同步，达到了写一个读一个的效果。

代码演示

共享资源实体类

class Res {
	public String userSex;
	public String userName;
	//线程通讯标识
	public boolean flag = false;
}

输入线程

class InpThrad extends Thread {
	private Res res;

	public InpThrad(Res res) {
		this.res = res;
	}

	@Override
	public void run() {
            int count = 0;
            while (true) {
	        synchronized (res) {
		if (res.flag) {
		    try {
			// 当前线程变为等待，但是可以释放锁
		        res.wait();
		    } catch (Exception e) {
                        // TODO: handle exception
		    }
		  }
		if (count == 0) {
		    res.userName = "小明";
		    res.userSex = "男";
		} else {
		    res.userName = "小红";
		    res.userSex = "女";
		}
		count = (count + 1) % 2;
		res.flag = true;
		// 唤醒其他等待线程
		res.notify();
		}
	    }
	}
}

输出线程

class OutThread extends Thread {
	private Res res;

	public OutThread(Res res) {
	    this.res = res;
	}

	@Override
	public void run() {
	    while (true) {
	        synchronized (res) {
	        if (!res.flag) {
		    try {
                        res.wait();
		    } catch (Exception e) {
		        // TODO: handle exception
                    }
		}

		System.out.println(res.userName + "--" + res.userSex);
		res.flag = false;
		res.notify();
		}
	    }
        }
}

运行结果

此时线程之间同步，达到了写一个读一个的效果。

4、 wait与sleep的区别?

对于sleep()方法，我们首先要知道该方法是属于Thread类中的，而wait()方法则是属于Object类中的。
sleep()方法导致了程序暂停执行指定的时间，让出cpu给其他线程，但是它的监控状态依然保持着，当指定的时间到了又会自动恢复运行状态。
wait使用在多线程之间同步（和synchronized 一起使用）
在调用sleep()方法的过程中，线程不会释放对象锁。而当调用wait()方法的时候，线程会释放对象锁，进入等待此对象的等待锁定池，只有此对象调用notify()方法后本线程才进入对象锁定池准备。

5、为什么wait和notify定义在object类中？

因为我们在用多线程进行同步时，锁是由我们自己定义的，为了让所有类都能够使用，所以把wait和notify定义在object类中。

6、Lock锁

在 jdk1.5 之后，并发包中新增了 Lock 接口(以及相关实现类)用来实现锁功能，Lock接口提供了与 synchronized 关键字类似的同步功能，但需要在使用时手动获取锁和释放锁。

Lock的写法

Lock lock  = new ReentrantLock();
lock.lock();
try{
    //可能会出现线程安全的操作
}finally{
    //一定要在finally中释放锁
    lock.unlock();
}

Lock 接口与 synchronized 关键字的区别

Lock 接口可以尝试非阻塞地获取锁当前线程尝试获取锁,如果这一时刻锁没有被其他线程获取到，则成功获取并持有锁。
Lock 接口能被中断地获取锁与 synchronized 不同，获取到锁的线程能够响应中断，当获取到的锁的线程被中断时，中断异常将会被抛出，同时锁会被释放。
Lock 接口在指定的截止时间之前获取锁，如果截止时间到了依旧无法获取锁，则返回。

Condition用法

Condition的功能类似于在传统线程技术中的wait()和notify()的功能

Condition condition = lock.newCondition();
res.condition.await();  //类似于wait
res.condition.signal(); //类似于notify

使用Lock同样可以实现上面的效果，代码演示如下：

共享实体资源类

class Res {
	public String userSex;
	public String userName;
	// flag=false时out线程未读取值
	public boolean flag = false;
	// 定义一个锁
	Lock lock = new ReentrantLock();
	Condition condition = lock.newCondition();
}

输入线程

class InpThread extends Thread {
	private Res res;

	public InpThread(Res res) {
		this.res = res;
	}
	@Override
	public void run() {
            int count = 0;
            while (true) {
		try {
		    res.lock.lock();
		    if (res.flag) {
			try {
			    // 当前线程变为等待，但是可以释放锁
			    // 类似于res.wait();
			    res.condition.await();
			} catch (Exception e) {

			}
		      }

		    if (count == 0) {
			    res.userName = "小明";
			    res.userSex = "男";
			} else {
			    res.userName = "小红";
			    res.userSex = "女";
			}

		    count = (count + 1) % 2;
		    res.flag = true;
		    // 唤醒当前线程 // 类似于res.notify();
		    res.condition.signal();
		} catch (Exception e) {
		    // TODO: handle exception
		} finally {
		    res.lock.unlock(); //释放锁，一定要在finally中
		}
	    }
	}
}

输出线程

class OutThread extends Thread {
	private Res res;

	public OutThread(Res res) {
		this.res = res;
	}

	@Override
	public void run() {
            while (true) {
		try {
		res.lock.lock();
		if (!res.flag) {
		    try {
		        res.condition.await();
		    } catch (Exception e) {
		        // TODO: handle exception
		    }
		}

		System.out.println(res.userName+"--"+res.userSex);
		res.flag = false;
		res.condition.signal();
	    } catch (Exception e) {

            } finally {
		res.lock.unlock();  //释放锁，一定要在finally中
            }
	}
    }
}

运行结果

所以使用Lock同样也可以实现上面的效果。

有头发的代码匠

发布了19 篇原创文章 · 获赞 279 · 访问量 8万+

私信关注