Java学习线程安全
线程同步（线程安全处理Synchronized）
线程同步的两种方式：
1、同步代码块
2、同步方法
同步代码块
同步代码块: 在代码块声明上 加上synchronized
synchronized (锁对象) {
可能会产生线程安全问题的代码
}
同步代码块中的锁对象可以是任意的对象；但多个线程时，要使用同一个锁对象才能够保证线程安全。
package com.oracle.demo01;
/*格式：
* synchronized(任意对象){
* 线程要操作的共享数据
* }
* 任意对象：同步对象、同步锁、对象监视器
* 同步怎么能保证安全性?
* 没有锁的线程不能执行，只能等待
*
* 线程获得CPU资源以后想要执行同步代码块的内容，它先去看一下同步锁有没有
* 如果有，那么你的线程获得锁，然后进入同步代码块执行代码，虽然在同步代码块中，线程休眠了
* 在此线程休眠时，其他线程获得资源想要执行同步代码块，它先去看一看有没有锁，一看，没有锁
* 它就被阻挡在代码块之后，只有等
* 休眠的线程睡完了，起来继续执行代码块中的内容，全部执行完代码块中的内容，就释放锁
* 然后其他线程获得锁，就可以继续执行了
*
* 线程安全了，那么执行速度就会变慢了
* */
public class Ticket implements Runnable {
private int ticket = 100;
Object obj = new Object();
@Override
public void run() {
// TODO Auto-generated method stub
while (true) {
synchronized (obj) {
if (ticket > 0) {
try {
Thread.sleep(10);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "出售第" + (ticket--) + "张票");
}
}
}
}
}
package com.oracle.demo01;
public class Test {
public static void main(String[] args) {
Ticket t = new Ticket();
Thread t0 = new Thread(t);
Thread t1 = new Thread(t);
Thread t2 = new Thread(t);
t0.start();
t1.start();
t2.start();
}
}
同步方法
同步方法：在方法声明上加上synchronized
public synchronized void method(){
可能会产生线程安全问题的代码
}
同步方法中的锁对象是 this
静态同步方法: 在方法声明上加上static synchronized
public static synchronized void method(){
可能会产生线程安全问题的代码
}
package com.oracle.demo02;
/*
*同步方法中有锁么？
*有锁，同步方法中的对象锁，就是本类对象引用 this
*StringBuffer：之所以安全，就是因为里面有同步方法，只要有同步，就安全，就慢
*StringBuilder：不安全，就是因为没有同步，就快
*
*如果你的同步方法时静态的，还有锁么？还是this么？
*有锁，不是this，是本类自己，也就是ticket.class 本类类名.class
* */
public class Ticket implements Runnable {
private int ticket = 100;
Object obj = new Object();
@Override
public void run() {
// TODO Auto-generated method stub
while (true) {
//synchronized (this)
synchronized (obj) {
method();
}
}
}
//同步代码块，代码更简洁
public synchronized void method() {
if (ticket > 0) {
try {
Thread.sleep(10);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "出售第" + (ticket--) + "张票");
}
}
}
package com.oracle.demo01;
public class Test {
public static void main(String[] args) {
Ticket t = new Ticket();
Thread t0 = new Thread(t);
Thread t1 = new Thread(t);
Thread t2 = new Thread(t);
t0.start();
t1.start();
t2.start();
}
}
Lock接口
Lock 实现提供了比使用 synchronized 方法和语句可获得的更广泛的锁定操作。
常用方法：
package com.oracle.demo03;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
/*
* JDK5以后出现Lock接口的可以代替同步关键字
* 功能是一样的，但是更灵活
* */
public class Ticket implements Runnable {
private int ticket = 100;
//接口不能实例化对象，就用子类的引用
private Lock l=new ReentrantLock();
@Override
public void run() {
// TODO Auto-generated method stub
while (true) {
l.lock();
if (ticket > 0) {
try {
Thread.sleep(10);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "出售第" + (ticket--) + "张票");
}else{
return;
}
l.unlock();
}
}
}
package com.oracle.demo03;
public class Test {
public static void main(String[] args) {
Ticket t = new Ticket();
Thread t0 = new Thread(t);
Thread t1 = new Thread(t);
Thread t2 = new Thread(t);
t0.start();
t1.start();
t2.start();
}
}
死锁
死锁的前提就是：一个线程必须同时拥有两个对象的资源才能执行程序。
1.线程1 首先占有对象1，接着试图占有对象2
2. 线程2 首先占有对象2，接着试图占有对象1
3. 线程1 等待线程2释放对象2
4. 与此同时，线程2等待线程1释放对象1
就会。。。一直等待下去，直到天荒地老，海枯石烂，山无棱 ，天地合。。。
2. 线程2 首先占有对象2，接着试图占有对象1
3. 线程1 等待线程2释放对象2
4. 与此同时，线程2等待线程1释放对象1
就会。。。一直等待下去，直到天荒地老，海枯石烂，山无棱 ，天地合。。。
package com.oracle.demo04;
public class LockA {
private LockA() {
}
//保证A锁的唯一性
public final static LockA la = new LockA();
}
package com.oracle.demo04;
public class LockB {
private LockB() {
}
//保证了B锁的唯一性
public final static LockB lb = new LockB();
}
package com.oracle.demo04;
public class DeadLock implements Runnable {
private int i = 0;
@Override
public void run() {
while (true) {
if (i % 2 == 0) {
synchronized (LockA.la) {
System.out.println("if...LockA");
synchronized (LockB.lb) {
System.out.println("if...LockB");
}
}
} else {
synchronized (LockB.lb) {
System.out.println("else...LockB");
synchronized (LockA.la) {
System.out.println("else...LockA");
}
}
}
i++;
}
}
}
package com.oracle.demo04;
public class Test {
public static void main(String[] args) {
DeadLock dl = new DeadLock();
Thread t0 = new Thread(dl);
Thread t1 = new Thread(dl);
t0.start();
t1.start();
}
}
等待唤醒机制
线程之间的通信：多个线程在处理同一个资源，但是处理的动作（线程的任务）却不相同。
等待唤醒机制：通过一定的手段使各个线程能够有效的利用资源，该手段就是等待唤醒机制
等待唤醒机制所涉及到的方法：
wait():等待，将正在执行的线程释放其执行资格和执行权，并存储到线程池中
notify():唤醒，唤醒线程池中被wait()的线程，一次唤醒一个，而且是任意的
notifyAll():唤醒全部，可以将线程池中的所有wait()线程都唤醒
所谓唤醒：就是让线程池中的线程具备执行资格。必须注意：这些方法都是在同步中才有效。同时这些方法在使用时必须表明所属锁，这样才可以明确这些方法操作的是哪个锁上的线程。
这些方法都被定义在Object类中了，因为这些方法在使用时，必须表明所属锁，而锁又可以是任意的，能被任意对象调用的方法一定定义在Object类中。
例如：
输入线程向Resource中输入name ,sex , 输出线程从资源中输出，先要完成的任务是：
l 1.当input发现Resource中没有数据时，开始输入，输入完成后，叫output来输出。如果发现有数据，就wait();
l 2.当output发现Resource中没有数据时，就wait() ；当发现有数据时，就输出，然后，叫醒input来输入数据。
package com.oracle.demo05;
public class Resouse {
public String name;
public String sex;
public boolean flag=false;
}
//flag标记：为true的时候，赋值完成
// 为false的时候，获取值完成
//输入类：true，等待，false，赋值，赋值完成后，把flag变为true notify输出，自己wait()
//输出类：false,等待，true，取值，取值完成后，把flag变为false notify输入，自己wait()
package com.oracle.demo05;
public class Input implements Runnable {
private Resouse r;
public Input(Resouse r) {
this.r = r;
}
@Override
public void run() {
// 往资源对象中输入数据
int i = 0;
while (true) {
//r表明锁的唯一性
synchronized (r) {
if (r.flag) {
try {
r.wait();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
if (i % 2 == 0) {
r.name = "张三";
r.sex = "女";
} else {
r.name = "lisi";
r.sex = "nan";
}
r.flag = true;
r.notify();
}
i++;
}
}
}
package com.oracle.demo05;
public class Output implements Runnable {
private Resouse r;
public Output(Resouse r) {
this.r = r;
}
@Override
public void run() {
// 从资源对象中输出数据
while (true) {
synchronized (r) {
if (!r.flag) {
try {
r.wait();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
System.out.println(r.name + "..." + r.sex);
r.flag = false;
r.notify();
}
}
}
}
package com.oracle.demo05;
public class Test {
public static void main(String[] args) {
Resouse r = new Resouse();
Input in = new Input(r);
Output out = new Output(r);
Thread tin = new Thread(in);
Thread tout = new Thread(out);
tin.start();
tout.start();
}
}
