Java多线程与线程安全：同步机制与线程池实践
本文探讨了Java中多线程环境下出现的线程安全问题，通过售票程序实例展示了线程不安全的现象。为了解决这一问题，文章介绍了同步代码块和同步方法，以及Lock接口的ReentrantLock实现，确保了资源的正确访问。此外，还提及了线程通信中的等待唤醒机制，线程组的概念，以及线程池的使用，特别是固定大小线程池（FixedThreadPool）。最后，文章提到了Callable接口和线程池结合执行任务的方式。
练习：电影院售票
某电影院目前正在上映贺岁大片，共有100张票，而它有3个售票窗口售票，请设计一个程序模拟该电影院售票。 两种方式实现 继承Thread类 实现Runnable接口，每次卖票延迟100毫秒
public class SellTicketDemo2 {
public static void main(String[] args) {
TicketDemo2 td = new TicketDemo2();
Thread w1 = new Thread(td, "窗口1");
Thread w2 = new Thread(td, "窗口2");
Thread w3 = new Thread(td, "窗口3");
w1.start();
w2.start();
w3.start();
}
public class TicketDemo extends Thread {
private static int ticket = 100;
Object obj = new Object();
@Override
public void run() {
while (true) {
if (ticket > 0) {
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(getName() + "正在出售第" + ticket-- + "张票");
}
}
}
这是我们根据上面的要求写出的代码；
我们来看看运行结果，我截取了部分，
按理来说应该是到0就停止了，怎么会出现这样的结果
问题出现在加入的Sleep方法，我们加入了延迟后 ，当前线程进入了阻塞状态，让其他线程执行假设线程一进去了run（）方法内，线程二和三紧跟着。在最后执行输出语句，他们三个几乎同时来到，第一个抢到资源的运行后ticket--后变为0，再一次会变成-1；
我们刚刚加入延迟的卖票程序出现的问题称之为线程安全问题。
要想解决这个问题，就应该去考虑哪些原因导致这些问题存在：
判断一个程序是否存在线程安全的标准
1、是否存在多线程环境
2、是否存在共享数据/共享变量
3、是否有多条语句操作着共享数据/共享变量
解决问题的思想：
要是有一个办法可以让多条语句控制共享数据包成一个整体，在某个线程执行的时候，别的线程进不来
知道某个线程执行完毕一次run方法之后，别的线程再进来。
Java提供了一个机制给我们使用，解决线程安全的问题：同步安全机制解决方式1：
同步代码块：
格式：
synchronized(对象)
{
需要同步的代码;
}
synchronized (obj) {
if (ticket > 0) {
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(getName() + "正在出售第" + (ticket--) + "张票");
问题得到了解决
接下来我们说第二种同步方法：同步方法
我们在方法上加入synchronized，我们在调用方法前也加上了锁synchronized，里面存放了this对象
public class TicketWindow2 implements Runnable{
//定义100张票
private int tickets = 100;
@Override
public void run() {
while (true) {
synchronized (this) {
sellTicket();
}
}
}
public synchronized void sellTicket(){
if(tickets>0){
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+" 正在出售第 "+(tickets--)+" 张票");
}
}
}
/*
1、同步代码块的锁对象是谁？
任意对象
2、同步方法的时候，锁对象又是谁呢？
this
同一时刻只允许一个对象进入方法
*/
public class SellTicketDemo2 {
public static void main(String[] args) {
TicketWindow2 ticketWindow1 = new TicketWindow2();
//创建3个线程模拟三个窗口
Thread t1 = new Thread(ticketWindow1, "窗口1");
Thread t2 = new Thread(ticketWindow1, "窗口2");
Thread t3 = new Thread(ticketWindow1, "窗口3");
t1.start();
t2.start();
t3.start();
}
修饰静态方法：
先将上面的方法中加入static,上面的变量也加入static（静态方法只能访问静态的成员变量）
运行结果
是静态同步方法，锁对象是该静态同步方法所属那个类的字节码文件
public class TicketWindow2 implements Runnable{
//定义100张票
private static int tickets = 100;
@Override
public void run() {
while (true) {
synchronized (TicketWindow2.class) {
sellTicket();
}
}
}
public static synchronized void sellTicket(){
if(tickets>0){
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+" 正在出售第 "+(tickets--)+" 张票");
}
}
}
public class TicketWindow2 implements Runnable{
//定义100张票
private static int tickets = 100;
@Override
public void run() {
while (true){
synchronized (TicketWindow2.class){
sellTicket();
}
}
}
public synchronized static void sellTicket(){
if(tickets>0){
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+" 正在出售第 "+(tickets--)+" 张票");
}
}
}
为了更清晰的表达如何加锁以及释放锁，在JDK1.5之后提供了一个新的锁对象Lock。
Lock:(接口)
具体的子类：ReentrantLock
void lock() 获得锁
void unlock() 释放锁。
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class TicketWindow3 implements Runnable {
private int ticket = 100;
Lock lock = new ReentrantLock();
@Override
public void run() {
while(true){
try{
lock.lock();
if(ticket>0){
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+"这是第"+(ticket--)+"张票");
}
}finally {
lock.unlock();
}
}
}
}
public class SellTicketDemo3 {
public static void main(String[] args) {
TicketWindow3 tw = new TicketWindow3();
Thread t1 = new Thread(tw, "窗口1");
Thread t2 = new Thread(tw, "窗口2");
Thread t3 = new Thread(tw, "窗口3");
t1.start();
t2.start();
t3.start();
}
}
线程通信：
经典案例：通过设置线程(生产者)和获取线程(消费者)针对同一个学生对象进行操作
我们虽然解决了线程安全问题，但是经过分析，程序中存在等待唤醒机制的问题。
加入等待唤醒机制。
如何添加等待唤醒机制呢？
Object类中有三个方法：
void wait() 导致当前线程等待，直到另一个线程调用该对象的 notify()方法或 notifyAll()方法。
void notify() 唤醒正在等待对象监视器的单个线程。
void notifyAll() 唤醒正在等待对象监视器的所有线程。
public class StudentDemo {
public static void main(String[] args) {
Student s=new Student();
GetThread getThread = new GetThread(s);
SetThread setThread = new SetThread(s);
Thread proThread = new Thread(setThread);
Thread cusThread = new Thread(getThread);
proThread.start();
cusThread.start();
}
}
public class SetThread implements Runnable {
private Student s;
private int x = 0;
public SetThread(Student s) {
this.s = s;
}
@Override
public void run() {
while (true) {
synchronized (s) {
if (s.flag) {
//设置等待机制，如果我们设置的数据还没有被读取完，我们进入等待
// 判断作用之一：如果我们先抢到资源，直接写数据
try {
s.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
if (x % 2 == 0) {
s.name = "路人甲";
s.age = 18;
} else {
s.name = "路人乙";
s.age = 19;
}
x++;
s.notify();//唤醒消费者那边因为wait产生的等待；
s.flag=true;
}
}
}
public class GetThread implements Runnable{
private Student s;
GetThread(Student s){
this.s=s;
}
@Override
public void run() {
while(true) {
synchronized (s) {
//消费者先抢到了资源，这是没有东西可以读，必须等待
//或者生产者还没有传入新的数据
if (!s.flag) {
try {
s.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println(s.name + "--" + s.age);
s.notify();
s.flag = false;
}
}
}
}
public class Student {
public int age;
public String name;
boolean flag=false;
//这里设置一个标记是为了判读后面创建的对象里是否有内容
}
部分运行结果：
总结前面的知识，给出线程的状态转换图：
这里synchronized只允许一个进程进入，将其他的进入等待也是阻塞。
线程组：
Java中使用ThreadGroup来表示线程组，它可以对一批线程进行分类管理，Java允许程序直接对线程组进行控制。 默认情况下，所有的线程都属于主线程组。
获得线程组的名字：public final ThreadGroup getThreadGroup()
我们也可以给线程设置分组： Thread(ThreadGroup group, Runnable target, String name)
public class ThreadGroupDemo {
public static void main(String[] args) {
MyRunnable myRunnable = new MyRunnable();
Thread t1 = new Thread(myRunnable, "线程1");
Thread t2 = new Thread(myRunnable, "线程2");
ThreadGroup tg1 = t1.getThreadGroup();
ThreadGroup tg2 = t2.getThreadGroup();
//默认情况下所有线程属于main方法
System.out.println(tg1.getName());
System.out.println(tg2.getName());
//获得当前进程的名字，由于我们是在main方法下
System.out.println(Thread.currentThread().getName());
//创建一个新的线程组
ThreadGroup tg3=new ThreadGroup("线程组1");
Thread t3= new Thread(tg3,myRunnable,"进程3");
Thread t4= new Thread(tg3,myRunnable,"进程4");
System.out.println(t3.getThreadGroup().getName());
}
}
线程池
程序启动一个新线程成本是比较高的，因为它涉及到要与操作系统进行交互。而使用线程池可以很好的提高性能，尤其是当程序中要创建大量生存期很短的线程时，更应该考虑使用线程池。 线程池里的每一个线程代码结束后，并不会死亡，而是再次回到线程池中成为空闲状态，等待下一个对象来使用。 在JDK5之前，我们必须手动实现自己的线程池，从JDK5开始，Java内置支持线程池。
我们通过Executors
其实Executors已经为我们封装好了 4 种常见的功能线程池，如下：
- 定长线程池（FixedThreadPool）
- 定时线程池（ScheduledThreadPool ）
- 可缓存线程池（CachedThreadPool）
- 单线程化线程池（SingleThreadExecutor)
我们这里简单介绍一下FixedThreadPool
public class ThreadPoolDemo {
public static void main(String[] args) {
ExecutorService pool=Executors.newFixedThreadPool(2);
//最多可以放入2个线程，多的不会运行
MyRunnable mb2 = new MyRunnable();
pool.submit(mb2);
pool.submit(mb2);
pool.submit(mb2);
//提交一个可运行的任务执行，并返回一个表示该任务的未来。
pool.shutdown();
//结束线程池
}
}
实现多线程的第三种方法：Callable(类似Runnable,继承接口，用子类实现线程的创建)
实现Callable接口，重写call方法，结合线程池运行；
<T> Future<T> submit(Callable<T> task)；
提交值返回任务以执行，并返回代表任务待处理结果的Future。
实现Callable接口的子类：
import java.util.concurrent.Callable;
public class MyCallable implements Callable {
@Override
public Object call() throws Exception {
for(int i=0;i<100;i++){
System.out.println(Thread.currentThread().getName()+"---"+i);
}
return null;
}
}
运行 ：
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class CallableDemo {
public static void main(String[] args) {
ExecutorService pool = Executors.newFixedThreadPool(2);
//submit(Runnable task,T result)提交一个可运行的任务执行，
// 并返回一个表示该任务的未来。
// 未来的get方法将在成功完成后返回给定的结果。
pool.submit(new MyRunnable());
pool.submit(new MyCallable());
pool.shutdown();
}
}
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
