1.8线程同步
并发 : 同一个对象被多个线程操作;
线程同步:
- 现实生活中,我们会遇到”同一个资源,多个人都想使用”的问题,比如,食堂排队打饭,每个人都想吃饭,最天然的解决办法就是,排队.一个个来.
- 处理多线程问题时,多个线程访问同一个对象,并且某些线程还想修改这个对象.这时候我们就需要线程同步. 线程同步其实就是一种等待机制,多个需要同时访问此对象的线程进入这个对象的等待池形成队列,等待前面线程使用完毕,下一个线程再使用.
队列和锁:
由于同一进程的多个线程共享同一块存储空间,在带来方便的同时,也带来了访问冲突问题
为了保证数据在方法中被访问时的正确性,在访问时加入锁机制synchronized ,当一个线程
获得对象的排它锁,独占资源,其他线程必须等待,使用后释放锁即可.存在以下问题:
- 一个线程持有锁会导致其他所有需要此锁的线程挂起;
- 在多线程竞争下,加锁,释放锁会导致比较多的上下文切换和调度延时,引起性能问题;
- 如果一个优先级高的线程等待一个优先级低的线程释放锁 会导致优先级倒置,引起性能问题.
不安全的取钱,怎么解决?
package com.gong.syn;
//不安全的取钱
public class UnsafeBank {
public static void main(String[] args) {
Accout accout = new Accout("结婚基金",100);
Drawing you = new Drawing(accout,50,"你");
Drawing grldfriend = new Drawing(accout,100,"女朋友");
you.start();
grldfriend.start();
}
}
class Accout {
String name;
int monery;
public Accout(String name, int monery) {
this.name = name;
this.monery = monery;
}
}
class Drawing extends Thread{
private Accout accout;
private int drawingMonery;//取了多少钱
private int nowMonery;//你手里的钱
public Drawing(Accout accout,int drawingMonery, String name) {
super(name);
this.accout = accout;
this.drawingMonery = drawingMonery;
}
@Override
public void run() {
if (accout.monery-drawingMonery<0){
System.out.println("钱不够,取不了");
return;
}
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
accout.monery -= drawingMonery;
nowMonery += drawingMonery;
System.out.println(accout.name+"余额为"+accout.monery);
//Thread.currentThread().getName()==this.getName()
System.out.println(this.getName()+"手里的钱"+nowMonery);
}
}
1.8.1 同步方法
- 由于我们可以通过private关键字来保证数据对象只能被方法访问,所以我们只需要针对方法提出一套机制,这套机制就是synchronized关键字,它包括两种用法:synchronized方法和synchronized块.
同步方法: public synchronized void method(int args) {} - synchronized方法控制对“对象”的访问,每个对象对应-把锁,每个synchronized方法都必须获得调用该方法的对象的锁才能执行,否则线程会阻塞,方法一旦执行 ,就独占该锁,直到该方法返回才释放锁,后面被阻塞的线程才能获得这个锁,继续执行
缺陷:若将一个大的方法申明为synchronized 将会影响效率
package com.gong.syn;
public class UnsafeBuyTicket {
public static void main(String[] args) {
BuyTicket buyTicket = new BuyTicket();
new Thread(buyTicket,"学生").start();
new Thread(buyTicket,"老师").start();
new Thread(buyTicket,"黄牛").start();
}
}
class BuyTicket implements Runnable{
private int tickets = 10;
private boolean flag = true;
@Override
public void run() {
while(flag){
try {
buy();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
//synchronized 同步方法 锁的是this
public synchronized void buy() throws InterruptedException {
if(tickets<=0){
flag = false;
return;
}
//模拟延时
Thread.sleep(100);
System.out.println(Thread.currentThread().getName()+"拿到了第"+tickets--+"票");
}
}
1.8.2同步块: synchronized (Obj ){}
-
Obj称之为同步监视器
-
Obj 可以是任何对象,但是推荐使用共享资源作为同步监视器
-
同步方法中无需指定同步监视器,因为同步方法的同步监视器就是this ,就是这个对象本身,
或者是class [反射中讲解]
-
-
同步监视器的执行过程
1.第一个线程访问,锁定同步监视器,执行其中代码.
2.第二个线程访问 ,发现同步监视器被锁定,无法访问.
3.第一个线程访问完毕 ,解锁同步监视器.
4.第二个线程访问, 发现同步监视器没有锁,然后锁定并访问
package com.gong.syn;
public class UnsafeBank {
public static void main(String[] args) {
Accout accout = new Accout("结婚基金",100);
Drawing you = new Drawing(accout,50,"你");
Drawing grldfriend = new Drawing(accout,100,"女朋友");
you.start();
grldfriend.start();
}
}
class Accout {
String name;
int monery;
public Accout(String name, int monery) {
this.name = name;
this.monery = monery;
}
}
class Drawing extends Thread{
private Accout accout;
private int drawingMonery;//取了多少钱
private int nowMonery;//剩下多少钱
public Drawing(Accout accout,int drawingMonery, String name) {
super(name);
this.accout = accout;
this.drawingMonery = drawingMonery;
}
@Override
public void run() {
//同步方法块 锁的对象是变化的量:增删改
synchronized (accout) {
if (accout.monery - drawingMonery < 0) {
System.out.println("钱不够,取不了");
return;
}
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
accout.monery -= drawingMonery;
nowMonery += drawingMonery;
System.out.println(accout.name + "余额为" + accout.monery);
//Thread.currentThread().getName()==this.getName()
System.out.println(this.getName() + "手里的钱" + nowMonery);
}
}
}
1.9 死锁
多个线程各自占有一些共享资源,并且互相等待其他线程占有的资源才能运行,而.导致两个或者多
个线程都在等待对方释放资源,都停止执行的情形. 某一个同步块同时拥有“两个以上对象的锁”时,
就可能会发生“死锁”的问题.
产生死锁的四个必要条件:
- 互斥条件: -个资源每次只能被一个进程使用。
- 请求与保持条件: -一个进程因请求资源而阻塞时,对已获得的资源保持不放。
- 不剥夺条件 :进程已获得的资源,在末使用完之前,不能强行剥夺。
- 循环等待条件 :若干进程之间形成一种头尾相接的循环等待资源关系。
package com.gong.syn;
//模拟死锁
//死锁:多个线程互相拿着对方的资源,然后形成僵持
public class DeadLock {
public static void main(String[] args) {
Makeup g1 = new Makeup(0,"小红");
Makeup g2 = new Makeup(1,"小蓝");
g1.start();
g2.start();
}
}
class Lipstick{}//口红
class Mirror{}//镜子
class Makeup extends Thread{
static Lipstick lipstick = new Lipstick();
static Mirror mirror = new Mirror();
int choice;//选择
String girlName;
public Makeup(int choice,String girlName){
this.choice = choice;
this.girlName = girlName;
}
@Override
public void run() {
try {
makeUp();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
public void makeUp() throws InterruptedException {
if(choice==0){
synchronized (lipstick){
System.out.println(this.girlName+"拿到了口红的锁");
Thread.sleep(1000);
synchronized (mirror){
System.out.println(this.girlName+"拿到了镜子的锁");
}
}
}else{
synchronized (mirror){
System.out.println(this.girlName+"拿到了镜子的锁");
Thread.sleep(2000);
synchronized (lipstick){
System.out.println(this.girlName+"拿到了口红的锁");
}
}
}
}
}