在多线程的处理之中,可以利用Runnable描述多个线程的操作资源,而Thread描述每一个线程对象,于是当多个线程访问统一资源的时候,如果处理不当就会产生数据的错误操作。
同步问题引出
下面编写一个简单的卖票程序,将创建若干个线程对象实现卖票的处理操作。
范例: 实现卖票操作
class MyThread implements Runnable {
private int ticket = 10; //门票
@Override
public void run() {
while(true) {
if( ticket > 0) {
System.out.println(Thread.currentThread().getName() + "卖票,ticket = " + this.ticket --);
} else {
System.out.println("####票已经卖光了");
break;
}
}
}
}
public class DemoThread {
public static void main(String[] args) {
MyThread myThread = new MyThread();
new Thread(myThread,"票贩子A").start();
new Thread(myThread,"票贩子B").start();
new Thread(myThread,"票贩子C").start();
}
}
此时的程序我们将创建三个线程对象,并且这三个线程对象将进行10张票的出售。那么此时的程序在进行卖票处理的时候,并没有出现任何问题(假象),下面可以模拟一下卖票中的延迟操作。
class MyThread3 implements Runnable {
private int ticket = 10; //门票
@Override
public void run() {
while(true) {
if( ticket > 0) {
try {
Thread.sleep(100); //模拟网络延迟
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "卖票,ticket = " + this.ticket --);
} else {
System.out.println("####票已经卖光了");
break;
}
}
}
}
输出结果可能出现负数现象:
票贩子C卖票,ticket = 3
票贩子B卖票,ticket = 3
票贩子A卖票,ticket = 2
票贩子C卖票,ticket = 1
####票已经卖光了
票贩子B卖票,ticket = 0
####票已经卖光了
票贩子A卖票,ticket = -1
####票已经卖光了
这个时候追加了延迟问题就暴漏出来了,而实际上这个问题一直都在。
如图,当ticket只剩一张票的时候,票贩子A进入程序,线程休眠了;而之后票贩子B又进入了程序,tikcet还是1,票贩子C同样可以进入程序休眠执行;当线程休眠过后,票贩子A和B同时买到最后一张票,票数变为了0,票贩子C再做卖票操作的时候ticket从0变为-1了。
线程同步处理
经过分析之后已经可以确认同步问题所产生的主要原因了,那么下面就是进行同步问题的解决,但是解决同步问题的关键是锁,指的是当某一个线程执行操作的时候,其他线程外面等待。
如果要想在程序之中实现这把锁的功能,就可以使用synchronized关键字来实现,利用此关键字可以定义我们的同步方法或同步代码块,在同步代码块的操作里面只允许一个线程进行执行。
1、利用同步代码块进行处理:
synchronized(同步对象){
同步代码操作;
}
一般要进行同步对象处理的时候,可以采用当前对象this进行同步。
范例: 利用同步代码解决数据同步访问问题
class MyThread3 implements Runnable {
private int ticket = 10; //门票
@Override
public void run() {
while(true) {
synchronized (this) {
if (ticket > 0) {
try {
Thread.sleep(100); //模拟网络延迟
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "卖票,ticket = " + this.ticket--);
} else {
System.out.println("####票已经卖光了");
break;
}
}
}
}
}
加入同步处理之后,程序的整体的性能下降了。同步实际上会造成性能的降低。
2、利用同步方法解决:只需要在同步方法添加synchronized关键字
class MyThread3 implements Runnable {
private int ticket = 10; //门票
public synchronized boolean sale(){
if (ticket > 0) {
try {
Thread.sleep(100); //模拟网络延迟
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "卖票,ticket = " + this.ticket--);
return true;
} else {
System.out.println("####票已经卖光了");
return false;
}
}
@Override
public void run() {
while(this.sale()) {
}
}
}
public class DemoThread {
public static void main(String[] args) {
MyThread3 myThread = new MyThread3();
new Thread(myThread,"票贩子A").start();
new Thread(myThread,"票贩子B").start();
new Thread(myThread,"票贩子C").start();
}
}
在日后学习java类库的时候会发现,系统中许多的类上使用的同步处理都是同步方法。
线程死锁
死锁是在进行多线程同步处理之中有可能产生的一种问题,**所谓的死锁之的是若干个线程彼此互相等待的状态。**下面我们通过一个简单的代码来观察一下死锁的表现形式。
范例: 死锁的变现
public class DeadLock implements Runnable{
private Jian jian = new Jian();
private Xiaoqiang xq = new Xiaoqiang();
public DeadLock() {
new Thread(this).start();
jian.say(xq);
}
@Override
public void run() {
xq.say(jian);
}
public static void main(String[] args) {
new DeadLock();
}
}
class Jian{
public synchronized void say(Xiaoqiang xq){
System.out.println("阿健说:要想从此过留下买路钱");
xq.get();
}
public synchronized void get(){
System.out.println("阿健:等我拿到钱就能吃饭了");
}
}
class Xiaoqiang{
public synchronized void say(Jian jian){
System.out.println("小强:先让我过去,在给你钱");
jian.get();
}
public synchronized void get(){
System.out.println("小强:我就可以继续送外卖了");
}
}
现在死锁造成的主要原因是因为彼此都在互相等待着,等待着对方先让出资源。死锁实际上是开发中出现的不确定的状态,有的时候代码如果处理不当,则会不定期出现死锁,这是属于正常开发中的调试问题。
若干个线程访问同一资源时一定要进行同步处理,而过多的同步会造成死锁。