Java学习提要——简述多线程的同步synchronized与死锁

同步，异步到底是什么，看下面的例子：

//正常输出
class MyThread implements Runnable {
private int ticket = 5 ;  //一共5张票
public void run() {
for(int x=0 ; x < 20 ; x++) {
if(this.ticket > 0) {
System.out.println(Thread.currentThread().getName() + " ticket =  " + this.ticket--);
}
}
}
}
public class Nice {
public static void main(String args[]) {
MyThread mt = new MyThread();
new Thread(mt,"AAA").start();
new Thread(mt,"BBB").start();
new Thread(mt,"CCC").start();
new Thread(mt,"DDD").start();
}
}

//加入延迟，非正常输出
class MyThread implements Runnable {
private int ticket = 5 ;  //一共5张票
public void run() {
for(int x=0 ; x < 20 ; x++) {
if(this.ticket > 0) {
try{
Thread.sleep(100);
}catch(InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + " ticket =  " + this.ticket--);
}
}
}
}
public class Nice {
public static void main(String args[]) throws Exception {
MyThread mt = new MyT
d417
hread();
new Thread(mt,"AAA").start();
new Thread(mt,"BBB").start();
new Thread(mt,"CCC").start();
new Thread(mt,"DDD").start();
}
}
//输出出现了负数，这就是不同步的情况

说实话，这个缘由，我也说不太清楚，我就举个例子吧。。

把上面程序分为三步：

1.判断是否有票

2.休眠

3.修改票数

比方，只有一张票了，取票三步为三重门，四个人来拿票，为四个线程，第一个过第一个门，还有票，进去了，但是第二道门要休眠，可以理解为住一晚上，第二、三、四个人也过第一门了，还有票，因为第一个人还没拿到票，票数还是一，剩下也是这样。第二天，第一个人醒了，过了第二门，去第三门拿了票，票数减一为零，但是第二、三、四个人此时都在第二门休息，由于他们进的时候都有票，等他们过了第二门的时候，第三门是要给人家票，于是继续减一减一就有了负数。。

那么，解决的方法就是，把上面的三重门,变成一个大房子，把三重门都放里面

意思就是，一个人进去，剩下的人不能进去，等待，等待这个人出来，再来判断有没有票，有票就进去。。

实现方法：

1.同步代码块

2.同步方法

例：

//同步块
class MyThread implements Runnable {
private int ticket = 5 ;  //一共5张票
public void run() {
for(int x=0 ; x < 20 ; x++) {
synchronized(this) {  //当前操作只允许一个对象进入
if(this.ticket > 0) {
try{
Thread.sleep(1000);
}catch(InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + " ticket =  " + this.ticket--);
}
}
}
}
}
public class Nice {
public static void main(String args[]) throws Exception {
MyThread mt = new MyThread();
new Thread(mt,"AAA").start();
new Thread(mt,"BBB").start();
new Thread(mt,"CCC").start();
new Thread(mt,"DDD").start();
}
}

//同步方法
class MyThread implements Runnable {
private int ticket = 5 ;  //一共5张票
public void run() {
for(int x=0 ; x < 20 ; x++) {
this.sale();  //调用同步方法
}
}
public synchronized void sale() {  //定义
if(this.ticket > 0) {
try{
Thread.sleep(1000);
}catch(InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + " ticket =  " + this.ticket--);
}
}
}
public class Nice {
public static void main(String args[]) throws Exception {
MyThread mt = new MyThread();
new Thread(mt,"AAA").start();
new Thread(mt,"BBB").start();
new Thread(mt,"CCC").start();
new Thread(mt,"DDD").start();
}
}

同步操作与异步操作相比，异步操作的执行速度要高于同步操作

但是同步操作数据的安全性较高，属于安全的线程操作

死锁就举个例子吧，没什么意义。

//死锁产生实例，程序本身没有意义,理解就好了
class A {
public synchronized void test(B b) {
System.out.println("你给我东西，我才给你钱");
b.get();
}
public synchronized void get() {
System.out.println("我得到东西，你得到钱");
}
}
class B {
public synchronized void test(A a) {
System.out.println("你给我钱，我才给你东西");
a.get();
}
public synchronized void get() {
System.out.println("我得到钱，你得到东西");
}
}
public class Nice implements Runnable {  //主类
private static A a = new A();
private static B b = new B() ;
public static void main(String args[]) {
new Nice() ;
}
public Nice() {
new Thread(this).start();
b.test(a);
}
public void run() {
a.test(b) ;
}
}