使用同步机制将单例模式中的懒汉式改写为线程安全的
package java1;
public class BankTest {
}
class Bank{
private Bank(){}
private static Bank instance = null;
public static synchronized Bank getInstance(){
if(instance == null){
instance = new Bank();
}
return instance;
}
}
演示线程的死锁问题
1.死锁的理解:不同的线程分别占用对方需要的同步资源不放弃,都在等待对方放弃自己需要的同步资源,就形成了线程的死锁
2.说明:
①出现死锁后,不会出现异常,不会出现提示,只是所有的线程都处于阻塞状态,无法继续。
②我们使用同步时,要避免出现死锁。
package java1;
public class ThreadTest {
public static void main(String[] args){
StringBuffer s1 = new StringBuffer();
StringBuffer s2 = new StringBuffer();
new Thread(){
@Override
public void run(){
synchronized (s1){
s1.append("a");
s2.append("1");
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
synchronized (s2){
s1.append("b");
s2.append("2");
System.out.println(s1);
System.out.println(s2);
}
}
}
}.start();
new Thread(new Runnable() {
@Override
public void run() {
synchronized (s2){
s1.append("c");
s2.append("3");
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
synchronized (s1){
s1.append("d");
s2.append("4");
System.out.println(s1);
System.out.println(s2);
}
}
}
}).start();
}
}
解决线程安全问题的方式三:Lock锁 - - - JDK5.0新增
1.实例化ReentrantLock
2.调用锁定方法:lock()
3.调用解锁方法:unlock()
package java1;
import java.util.concurrent.locks.ReentrantLock;
class Window implements Runnable{
private int ticket = 100;
private ReentrantLock lock = new ReentrantLock();
@Override
public void run(){
while (true){
try {
lock.lock();
if (ticket > 0){
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + ":售票,票号为:" + ticket);
ticket--;
}else {
break;
}
}finally {
lock.unlock();
}
}
}
}
public class LockTest {
public static void main(String[] args) {
Window w = new Window();
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();
}
}
synchronized 与 lock的异同?
相同:二者都可以解决线程安全问题
不同:synchronize机制在执行完相应的同步代码以后,自动的释放同步监视器
Lock需要手动的启动(lock()),同时结束同步有也需要手动的实现(unlock())
练习:银行有一个账户。
有两个储户分别向一个账号存3000元,每次存1000,存3次。每次纯完打印账户余额。
package exer;
class Account{
private double balance;
public Account(double balance) {
this.balance = balance;
}
public synchronized void deposit(double amt){
if (amt > 0){
balance += amt;
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println( Thread.currentThread().getName() + "存钱成功,余额为:" + balance);
}
}
}
class Customer extends Thread{
private Account acct;
public Customer(Account acct){
this.acct = acct;
}
@Override
public void run() {
for (int i = 0; i < 3; i++) {
acct.deposit(1000);
}
}
}
public class AccountTest {
public static void main(String[] args) {
Account acct = new Account(0);
Customer c1 = new Customer(acct);
Customer c2 = new Customer(acct);
c1.setName("甲");
c2.setName("乙");
c1.start();
c2.start();
}
}
线程通信的例子:使用两个线程打印1-100。线程1,线程2,交替打印
涉及到的三个方法:
wait():一旦执行此方法,当前线程就进入阻塞状态,并释放同步监视器。
notify():一旦执行此方法,就会唤醒被wait的一个线程。如果有多个线程被wait,就唤醒优先级高的那个。
notifyAll():一旦执行此方法,就会唤醒所有的被wait的线程。
说明:
1.wait(),notify(),notifyAll()三个方法必须使用在同步代码块或同步方法中。
2.wait(),notify(),notifyAll()三个方法的调用者必须是同步代码块或同步方法中的同步监视器。否侧,会出现illegalMonitorStateException异常
3.wait(),notify(),notifyAll()三个方法是定义在java.lang.Object类中。
package com.atguigu.exer.java2;
class Number implements Runnable {
private int number = 1;
@Override
public void run() {
while (true) {
synchronized (this) {
notify();
if (number <= 100) {
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + ":" + number);
number++;
try {
wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
} else {
break;
}
}
}
}
}
public class CommunicationTest {
public static void main(String[] args) {
Number number = new Number();
Thread t1 = new Thread(number);
Thread t2 = new Thread(number);
t1.setName("线程1");
t2.setName("线程2");
t1.start();
t2.start();
}
}
sleep() 和 wait()的异同?
1.相同点:一旦执行方法,都可以使得当前的线程进入阻塞状态。
2.不同点:①两个方法声明的位置不同:Thread类中声明sleep(),Object类中声明wait()
②调用的范围不同:sleep()可以在任何需要的场景下调用。wait()必须使用在同步代码块或同步方法中。
③关于是否释放同步监视器:如果两个方法都使用在同步代码块或同步方法中,slepp()不会释放锁,wait()会释放锁。