线程安全
同步代码块实现线程的安全 ①：实现的方式的多线程同步代码块：
package seventeen;
//使用实现Runnable接口的方式，售票
/*
* 此程序存在线程的安全问题：打印车票时，会出现重票、错票
* 1.线程安全问题存在的原因？
* 由于一个线程在操作共享数据过程中，未执行完毕的情况下，另外的线程参与进来，导致共享数据存在了安全问题。
*
* 2.如何来解决线程的安全问题？
* 必须让一个线程操作共享数据完毕以后，其它线程才有机会参与共享数据的操作。
*
* 3.java如何实现线程的安全：线程的同步机制
*
* 方式一：同步代码块
* synchronized(同步监视器){
* //需要被同步的代码块（即为操作共享数据的代码）
* }
* 1.共享数据：多个线程共同操作的同一个数据(变量)
* 2.同步监视器：由一个类的对象来充当。哪个线程获取此监视器，谁就执行大括号里被同步的代码。俗称：锁
* 要求：所有的线程必须共用同一把锁！
* 注：在实现的方式中，考虑同步的话，可以使用this来充当锁。但是在继承的方式中，慎用this!
*
* 方式二：同步方法
*
*
*/
class Window2 implements Runnable {
int ticket = 100;// 共享数据
// Object obj = new Object();
public void run() {
// Animal a = new Animal();//局部变量
while (true) {
synchronized (this) {//this表示当前对象，本题中即为w
if (ticket > 0) {
try {
// Thread.currentThread().sleep(10);
Thread.sleep(10);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()
+ "售票，票号为：" + ticket--);
}
}
}
}
}
public class TestWindow2 {
public static void main(String[] args) {
Window2 w = new Window2();
Thread t1 = new Thread(w);
Thread t2 = new Thread(w);
Thread t3 = new Thread(w);
t1.setName("窗口1");
t2.setName("窗口2");
t3.setName("窗口3");
t1.start();
t2.start();
t3.start();
}
}
class Animal{
}
②：继承于 Thread 类的多线程 同步代码块：
package seventeen;
//模拟火车站售票窗口，开启三个窗口售票，总票数为100张
//存在线程的安全问题--->使用同步代码块处理。
class Window3 extends Thread {
static int ticket = 100;
static Object obj = new Object();//使用静态的方式实现类的对象为独一份。
public void run() {
while (true) {
// synchronized (this) {//在本问题中，this表示：w1,w2,w3
synchronized (obj) {
// show();
if (ticket > 0) {
try {
// Thread.currentThread().sleep(10);
Thread.sleep(10);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()
+ "售票，票号为：" + ticket--);
}
}
}
}
// public synchronized void show() {// this充当的锁
// if (ticket > 0) {
// try {
// // Thread.currentThread().sleep(10);
// Thread.sleep(10);
// } catch (InterruptedException e) {
// // TODO Auto-generated catch block
// e.printStackTrace();
// }
// System.out.println(Thread.currentThread().getName() + "售票，票号为："
// + ticket--);
// }
// }
}
public class TestWindow3 {
public static void main(String[] args) {
Window3 w1 = new Window3();
Window3 w2 = new Window3();
Window3 w3 = new Window3();
w1.setName("窗口1");
w2.setName("窗口2");
w3.setName("窗口3");
w1.start();
w2.start();
w3.start();
}
}
同步方法实现线程的安全 ①：实现的方式的多线程同步方法：②：继承于 Thread 类的多线程中 this 非独一份，故无法使用。
package seventeen;
//使用实现Runnable接口的方式，售票
/*
* 此程序存在线程的安全问题：打印车票时，会出现重票、错票
* 1.线程安全问题存在的原因？
* 由于一个线程在操作共享数据过程中，未执行完毕的情况下，另外的线程参与进来，导致共享数据存在了安全问题。
*
* 2.如何来解决线程的安全问题？
* 必须让一个线程操作共享数据完毕以后，其它线程才有机会参与共享数据的操作。
*
* 3.java如何实现线程的安全：线程的同步机制
*
* 方式一：同步代码块
* synchronized(同步监视器){
* //需要被同步的代码块（即为操作共享数据的代码）
* }
* 1.共享数据：多个线程共同操作的同一个数据(变量)
* 2.同步监视器：由一个类的对象来充当。哪个线程获取此监视器，谁就执行大括号里被同步的代码。俗称：锁
* 要求：所有的线程必须共用同一把锁！
* 注：在实现的方式中，考虑同步的话，可以使用this来充当锁。但是在继承的方式中，慎用this!
*
* 方式二：同步方法
* 将操作共享数据的方法声明为synchronized。即此方法为同步方法，能够保证当其中一个线程执行
* 此方法时，其它线程在外等待直至此线程执行完此方法。
* >同步方法的锁：this
*
* 4.线程的同步的弊端：由于同一个时间只能有一个线程访问共享数据，效率变低了。
*
*/
class Window4 implements Runnable {
int ticket = 100;// 共享数据
public void run() {
while (true) {
show();
}
}
public synchronized void show() {
if (ticket > 0) {
try {
Thread.currentThread().sleep(10);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "售票，票号为："
+ ticket--);
}
}
}
public class TestWindow4 {
public static void main(String[] args) {
Window4 w = new Window4();
Thread t1 = new Thread(w);
Thread t2 = new Thread(w);
Thread t3 = new Thread(w);
t1.setName("窗口1");
t2.setName("窗口2");
t3.setName("窗口3");
t1.start();
t2.start();
t3.start();
}
}
互斥锁_单例之懒汉式的线程安全：
package seventeen;
//关于懒汉式的线程安全问题：使用同步机制
//对于一般的方法内，使用同步代码块，可以考虑使用this。
//对于静态方法而言，使用当前类本身充当锁。
class Singleton {
private Singleton() {
}
private static Singleton instance = null;
public static Singleton getInstance() {
if (instance == null) {
synchronized (Singleton.class) {
if (instance == null) {
instance = new Singleton();
}
}
}
return instance;
}
}
public class TestSingleton {
public static void main(String[] args) {
Singleton s1 = Singleton.getInstance();
Singleton s2 = Singleton.getInstance();
System.out.println(s1 == s2);
// Class clazz = Singleton.class;
}
}
小结：释放锁的操作：
- 当前线程的同步方法、同步代码块执行结束
- 当前线程在同步代码块、同步方法中遇到
break、return终止了该代码块、该方法的继续执行。 - 当前线程在同步代码块、同步方法中出现了未处理的
Error或Exception，导致异常结束 - 当前线程在同步代码块、同步方法中执行了线程对象的
wait()方法，当前线程暂停，并释放锁。
小结：不会释放锁的操作：
-
线程执行同步代码块或同步方法时，程序调用
Thread.sleep()、Thread.yield()方法暂停当前线程的执行 -
线程执行同步代码块时，其他线程调用了该线程的 suspend() 方法将该线程挂起，该线程不会释放锁（同步监视器）。
- 应尽量避免使用 suspend() 和 resume() 来控制线程
线程同步的练习：
package seventeen;
/*
* 银行有一个账户。
有两个储户分别向同一个账户存3000元，每次存1000，存3次。每次存完打印账户余额。
1.是否涉及到多线程？是！有两个储户(两种方式创建多线程)
2.是否有共享数据？有！同一个账户
3.得考虑线程的同步。（两种方法处理线程的安全）
//拓展：实现二者交替打印。使用线程的通信
*/
class Account{
double balance;//余额
public Account(){
}
//存钱
public synchronized void deposit(double amt){
notify();
balance += amt;
try {
// Thread.currentThread().sleep(10);
Thread.sleep(10);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + ":" + balance);
try {
wait();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
class Customer extends Thread{
Account account;
public Customer(Account account){
this.account = account;
}
public void run(){
for(int i = 0;i < 3;i++){
account.deposit(1000);
}
}
}
public class TestAccount {
public static void main(String[] args) {
Account acct = new Account();
Customer c1 = new Customer(acct);
Customer c2 = new Customer(acct);
c1.setName("甲");
c2.setName("乙");
c1.start();
c2.start();
}
}
韧桂 2020-01-10