Video在线视频

在上一节当中

我们已经介绍了线程同步的思想

那在这一节当中

我们将介绍采用何种方式

来实现线程同步

那怎么样才能够避免这个情况呢

就会用到我们线程同步的这个知识

线程同步往往是和我们线程的互斥

这个在一起的

什么叫互斥呢

许多线程在同一个共享上操作

而互不干扰

这就要求同一时刻

只有一个线程访问该共享数据

那因此有些方法或程序

在同一时间只能被一个线程执行

我们把它称之为监视区

那其实线程之间也是可以协作的

也就是说多个线程

可以有条件的同时操作

有一些共享数据

执行监视区代码的线程

在条件满足的情况下

它也可以允许其他线程

进入到这个监视区

那我们怎么实现这种互斥与同步

我们就需要用到关键字synchronized

synchronized的作用

是用于指定需要同步的代码段

或者方法

那这个synchronized

它是实现了一个

这个对象锁的这个交互

那一般它的这个代码格式是这样的

你先写synchronized

后面一个小括号

里面是你要交互的这个对象

也就是你要访问的这个对象

然后再把代码段放进去

也就是你访问这个对象的时候

你要做一些操作

那这个从语法上这么写完了以后

那synchronized的功能是干嘛呢

它首先要判断

你这个对象的锁是否存在

如果这个锁存在的话

就可以执行后面这个代码段

如果这个锁不存在

为什么不存在呢

因为这个锁已经被其他线程拿到了

然后其他线程正在访问这个对象

所以你这个当前对象

想访问这个数据的话

你又访问不了

那你这个线程就得进入等待状态

一直到其他线程释放出这个锁以后

你才能得到锁

那什么情况下会释放锁呢

也就是说我这个线程

在synchronized那个代码段

一执行完了以后

就会把这个对象的锁给释放出来

那有了synchronized这个关键字的

这种作用

我们就考虑说

怎么把它运用到我们刚才

这个售票存票的这个过程当中

那我们就希望说

把我们的存票线程和售票线程

让它设置成一种互斥关系

也就是说这两个线程

任意一个去访问ticket这个对象的时候

就不允许另外一个线程

去访问ticket这个对象

那对于ticket这样的对象的话

它就有一个锁

其他线程想访问ticket这样对象的话

它就必须争夺这个锁

那比如说当某个线程A

获得这个对象的锁后

线程B就必须等待线程A完成

自己规定的操作

释放出锁以后

这个线程B才能获得这个对象的锁

然后它才会执行线程B中的

自己希望的操作

那我们利用synchronized这个关键字

来去改造一下

刚才我们上述的这个存票售票的过程

我们看一下这个类

class producer extend Thread

然后tickets t=null

然后这个producer的构造方法

就是把这个tickets t对象传进去

然后我们看一下public void run方法

然后while t.number小于t.size

也就是我们产生了这个票号

比我们的这个票的总量小

然后这个时候

我们看看这个语句怎么改进来

synchronized（t）也就是说

我在我这个线程producer当中

我现在要访问我的这个tickets

这个对象t

我用synchronized那个加上以后

我要申请对象t的锁

而假定运行过程中

我申请到了 我做什么事情呢

就是这system.out.println

然后producer puts ticket

然后++t.number

也就是说我生产出一张票来

然后t.available=true

然后说有票可卖了

其实说白了最重要就是

把这两行代码变成一个（原子）操作

就是在执行过程中

不可能被打散执行

然后当这个synchronized范围

这些语句执行完了以后

它自然而然就会释放对象t的锁

再往下那句代码

system.out println（producer ends）

所以大家看看我们这里已经

用synchronized来改造了一下

我们producer的这个代码

那我们再看看怎么用synchronized

来改造一下这个consumer这个代码

好 我们直接就看改造的那部分了

while i小于t.size

也就是说我要卖的票

比我们的这个票的这个总数

这个还是要小

说明我可以卖

好 我卖票的时候我synchronized（t）

也就是说申请对象t的锁

也就是申请对象t的锁的话

就要求我这时候就是我这些人

去访问这个ticket这个对象

别的进程不允许访问在这个时刻

那我访问ticket对象

我要做什么事情呢

大家看里面的代码

if（t.available=true&&

i小于等于t.number

也就是说有票可卖

而且我想要卖的这个票

比我们那个生产出来的票号

要小于等于它

那我就可以卖票了

那怎么卖呢

那system.out.println

consumer buys ticket+（++i）

也就是打印出来我把票卖掉了

然后if（i）==t.number

然后就意味着我们要卖到

这个最后一张票了

那这个时候我们就是休眠一毫秒

try Thread sleel

然后最后t.available=false

也就是说无票可卖了

然后这些代码执行完以后

它自然而然会释放对象t的锁

那其实提醒大家的是

用synchronized

后面大括号括起来其实是代码

实际上它把它变成一个原子操作

也就是说当我拿到这个

对象t的锁的时候

我这里面的这些代码

是肯定都会被执行的

不会说我执行某一句以后

就被这个打断

然后那个插入别的线程去执行

去访问这个对象t

所以这个是synchronized

它的很重要的作用

那经过这样的一个改造了以后

同学们可以再自己运行一下

我们这个改造后的程序

你就会发现我们的这个存票售票程序

应该不会出现死循环的这个现象了

那这里面最重要的就是我们的

synchronized关键字

实际上我们是通过这个关键字

把存票这个线程和售票线程

对同样一个对象

也就是ticket这个对象的任务访问

把它变成一种互斥操作

也就是说不能让两个线程

都同时去访问这个对象

而必须是说其中一个线程

访问这个ticket这个对象

别的就必须等它访问完

把所有的操作都做完以后

才允许它访问

那当我们的线程执行到

synchronized的时候

它的功能是这样

它要检查传入的实参对象

并申请得到该对象的锁

如果得不到的话

那这个线程就会被放到

与该对象锁所对应的等待池线程当中

直到这个对象的锁被归还

那这个池中的等待线程

才能重新去获得锁

然后才继续执行

那我们除了可以指定

对指定的代码段进行同步控制外

还可以定义某些方法

在同步控制下执行

只要在方法定义前面

加上synchronized关键字就可以了

那我们把上面的例子

再稍微改进一下

我们最重要的是改进

是把这个ticket这个类进行改进

然后给它增加两个方法

而且都设置成为同步的方法

我们看一下这个改进后的类

class tickets

那前面这些它的这个成员变量

和它的购票方法都没有变化

我们看一下新增的两个方法

第一个方法叫

public synchronized void put

同步方法

就是往里面实现存票的功能

我们看一下它的功能是什么

system.out.println

producer puts ticket++number

往里存一张票

所以available=true

那实际在这个方法中

它有两句代码

那由于加上同步synchronized

这个功能以后

那这个方法它里边的代码

就变成原子操作了

这两张代码肯定是要

能被同时执行的

我们再看一下另外一个方法

public synchronized void sell

它也是一个同步方法

它实现售票的功能

那它售票功能的话

它就会判断说if available=true

就是说是不是有票可卖

并且i小于等于number

就要我要卖票和你生产出来票的

那个票号是小于等于它的

可以卖票了

卖票的过程就模拟一下

就打印出consumer buysticket

加上++i

然后最后来判断一下

是不是票都卖没了

如果卖没了

那就available=false

所以我们现在通过这么一个改造的话

就把ticket它增加两个方法

而且是同步方法

这样的话当其他线程

要访问ticket这个类的时候

就可以通过它这两个方法来去访问

那我们看一下这个producer

和consumer又有什么修改

class producer extends Thread

然后我们看一下

主要看它的run方法

run方法的话

比以前有简化了

就是while（t.number

然后t.put

也就是说如果我们存票数

小于要限定的总量的话

我们就不断的去产生票

就把它存进去

通过调用t的put方法去存票

我们再看看consumer怎么改造的

Class consumer extends Thread

然后我们看看run方法

while（t.i

也就是说我们要售票的数量

小于你限定的总量

那我就不停的售票

那怎么售票呢

就是t.sell 用sell的方法

需要注意说我们这个sell方法

也是个同步方法

和刚才那个put方法都是同步方法

那通过这么样一个控制以后

我们这个程序这个线程执行起来

就会避免它出错

那我们再看看就是说这一部分

线程的同步和锁之间

都有什么重要的要点

首先我们只能同步方法

不能同步变量

也就是说我们synchronized的话

你去同步的话

是我们这个 （就是）我们一个方法

另外每个对象只有一个锁

我们当提到同步的时候

应该清楚在什么对象上同步

因为同步的话是因为我们

原因是我们要对某个对象进行访问

就是若干个线程对于某一个对于

进行访问

那这个时候其实锁是和这个对象

在一起的

第三点是我们类可以同时拥有

同步和非同步方法

非同步方法可以被多个线程自由访问

而不受锁的限制

如果两个线程同时使用

相同的实例来调用synchronized方法

那么一次只能有一个线程执行方法

另一个需要等待锁

这个是很自然这个事情

再提醒大家有一点

线程休眠的时候

它所持有的任何锁都不会释放

这一点就是非常有意思的一点

大家不要以为说

我这线程休眠的时候

我会释放锁

就像刚才我们那个例子

我们在这个售票线程里面

每售出来票的时候

它就会休眠一毫秒

但休眠一毫秒的时候

它不会释放出它所占有的

这个ticket对象的锁的

它一直会持有

所以这是一个独特的一个地方

我们线程还可以获得多个锁

比如说在一个对象的同步方法里面

我又调用了另外一个对象的同步方法

然后获取了两个对象的同步锁

这是允许的

另外一个原则是这样

同步它会损害并发性

应该尽可能的缩小同步范围

大家也看到了就是说

比如说两个线程都访问

同样一个对象

如果这个对象上好些方法

都给它加上同步的话

那基本上就是说我一个

一个线程访问这个对象的时候

另外一个线程只能等着

那如果等的情况多的话

那你就会损害这个

这两个线程之间的并发的性能

所以大家在（编程）区要考虑清楚说

我这一个数据对象

到底哪些方法是需要同步方法

哪些不需要

如果你能缩小这个同步方法的话

你就是可以让我们的这个

整个程序的这个并发性得到提高

那我们在使用同步代码块的时候

应该指定是在哪个对象同步

也就是说要说明获取的是

哪个对象的锁

所以我们java线程中的同步和锁

是息息相关的

希望大家能够很好的理解

这部分的内容

在这一节当中

我们通过介绍synchronized

来阐述了如何实现线程同步