这里将会系统的讲一遍我们在JAVA使用过程中学到的所有的锁，先简单给大家介绍一下有那些锁：
对象锁
this锁
类锁
定义
锁就是把对象看成锁，只有拿到锁的线程才能够对锁里面的代码块进行操作，其他线程即使拿到了执行资格和执行权限，必须等到锁被释放后争夺锁的使用权限才能进去锁的内部代码块
对象锁
格式：
synchronized(对象)
｛
共享数据代码块操作
｝
这里举一个线程通信的例子帮助大家理解
线程通信：简单来说就是两个线程对同一资源进行输入和输出操作
public class sharedResource {
String Message;
String name;
}
//对共享区域中的数据进行赋值----存数据
public class Input implements Runnable{
sharedResource s;
Input (sharedResource s)
{
this.s=s;
}
public void run() {
s.name="周志华";
s.Message="花书";
System.out.println(s.name+"------>"+s.Message);
}
}
//对共享区域中的数据进行取数据----也就是把数据中的数据进行置空
public class Output implements Runnable{
sharedResource s;
Output (sharedResource s)
{
this.s=s;
}
public void run() {
s.name=" ";
s.Message=" ";
System.out.println(s.name+"------>"+s.Message);
}
}
public class TestDemo {
public static void main(String[] args) {
sharedResource s=new sharedResource();
Input i=new Input(s);
Output o=new Output(s);
Thread t1=new Thread(i);
Thread t2=new Thread(o);
t1.start();
t2.start();
}
}
自行多打印几次，可以发现数据会出现混乱
我们来找到操作共享数据代码块，分别是：
public void run() {
s.name=" ";
s.Message=" ";
System.out.println(s.name+"------>"+s.Message);
}
和
public void run() {
s.name="周志华";
s.Message="花书";
System.out.println(s.name+"------>"+s.Message);
}
修改一下：
public void run() {
synchronized(s) {
s.name=" ";
s.Message=" ";
System.out.println(s.name+"------>"+s.Message);
}
}
public void run() {
synchronized(s)
{
s.name="周志华";
s.Message="花书";
System.out.println(s.name+"------>"+s.Message);
}
}
这里的对象其实随意用就行，我们仅仅是把它当作一个唯一的锁，但是关键
锁必须是同一个
类锁
其实我更加愿意把它称为静态锁，原因在于它是针对静态方法的，然后静态方法又是操作静态变量
格式:
synchronized(字节代码块)
｛
共享数据代码块操作
｝
见代码：
//对共享区域中的数据进行赋值----存数据
public class Input implements Runnable{
static sharedResource s;//静态对象
Input (sharedResource s)
{
this.s=s;
}
static void put() {//静态方法
s.name="周志华";
s.Message="花书";
System.out.println(s.name+"------>"+s.Message);
}
public void run() {
synchronized(sharedResource.class)//静态锁
{
put();
}
}
}
//对共享区域中的数据进行取数据----也就是把数据中的数据进行置空
public class Output implements Runnable{
static sharedResource s;
Output (sharedResource s)
{
this.s=s;
}
static void put() {
s.name=" ";
s.Message=" ";
System.out.println(s.name+"------>"+s.Message);
}
public void run() {
synchronized(sharedResource.class) {
put();
}
}
}
类锁的根本原因就是在于这里put()是静态方法，静态方法如果把对象拿来作为锁，就会出现可能对象还未创建，但是静态方法已经执行了。显然，这不合时，于是才产生了类锁。
this锁
本质就是synchronized（x）需要传入this，也就是当前对象作为锁。
格式：
void function()
{
synchronized(this){
操作共享数据代码块；
}
}
可以对该格式进行修改，也就是把synchronized和函数名并列，即：
synchronized void function()
{
操作共享数据代码块；
}
两种写法均正确
就是针对多个线程对同一对象进行操作的情况，这里写一个多线程卖票系统，根据这个例子来，会更加清楚，见代码
public class Ticket implements Runnable{
private int num=1000;
Object obj=new Object();
synchronized void function() {
System.out.println(Thread.currentThread().getName()+"剩余------->"+(num--));
}
public void run() {
synchronized(obj){//确保票不会出现负数
while(num>0)
//this.function();
function();
}
}
}
public class stasticTestDemo {
public static void main(String[] args) {
Ticket t=new Ticket();
Thread t1=new Thread(t);
Thread t2=new Thread(t);
Thread t3=new Thread(t);
Thread t4=new Thread(t);
t1.start();
t2.start();
t3.start();
t4.start();
}
}
这里来分析一下，我们建了4个线程来对同一对象进行卖票操作，在Ticket类中用了两个锁，一个对象锁，来操作共享数据代码块，从而来确保数据的准确性，不会出现负数情况。
对于this锁，本质在于function()方法的调用者就是this，我们锁住的就是this
死锁
JAVA锁机制在使用的时候也要防止锁会出现新的问题----死锁
死锁指的是多个对象对有限资源进行抢夺，从而形成的一种循环等待僵持的状态。本质就是在于对象众多，而资源有限，从而形成循环等待的情况
死锁的四个条件
持有请求：自己持有了资源并且继续抢夺
循环等待：形成了一个循环等待的圈子，简而言之：A请求B中持有的资源，B请求C中持有的资源，C又持有A中持有的资源，从而形成了一个循环等待的圈子
不可剥夺：资源不可以被随意剥夺
互斥条件：资源非共享，限于单独使用
直接上代码
//死锁案例,获得this锁再申请对象锁
//获得了对象锁再申请this锁
public class deadLock {
Object obj=new Object();//对象锁
int flag=0;
void show() {//this锁
if(flag%2==0)
{
synchronized(this) {
System.out.println("if this锁");
synchronized(obj)
{
System.out.println("if obj锁");
}
}
}
else
{
synchronized(obj)
{
System.out.println("else obj锁");
synchronized(this)
{
System.out.println("else this锁");
}
}
}
flag++;
}
}
public class student implements Runnable{
deadLock d=new deadLock();
student(deadLock d)
{
this.d=d;
}
public void run() {
while(true)
d.show();
}
}
public class TestDemo {
public static void main(String[] args) {
deadLock d =new deadLock();
student s1=new student(d);
student s2=new student(d);
Thread t1=new Thread(s1);
Thread t2=new Thread(s2);
t1.start();
t2.start();
}
}
我们按着死锁的定义来分析一下
s1获得了其中一个锁会紧接着继续申请另外一个锁，恰好另外一个锁很有可能正在s2中，同时s2会继续申请s1中的锁，形成了循环等待队列，形成一种僵持状态，即死锁
总结
锁分成三种，类锁，针对静态方法。对象锁，以某一具体对象作为锁。this锁，本质在于调用方法的对象是this（当前对象），所以我们可以简化把synchronized和方法名并列。
