Java多线程篇

使用同步机制将单例模式中的懒汉式改写为线程安全的

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()会释放锁。