Java多线程

多线程[Thread]

多线程是Java语言的重要特性，大量应用于网络编程、服务器端程序的开发，最常见的UI界面底层原理、操作系统底层原理都大量使用了多线程。
1、程序、进程与线程
程序Program
　　• 程序是一段静态的代码，指令的集合。
进程Process
　　• 进程是指一种正在运行的程序，有自己的地址空间，进程是 系统 进行资源分配的最小单位。多个进程之间不共享资源。
进程的特点： 动态性、并发性、独立性
并发和并行的区别
　　• 多个CPU同时执行多个任务
　　• 一个CPU（采用时间片）同时执行多个任务
线程Thread
• 进程内部的一个执行单元，它是程序中一个单一的顺序控制流程。
• 线程又被称为轻量级进程(lightweight process)
• 如果在一个进程中同时运行了多个线程，用来完成不同的工作，则称之为 多线程
• 一个进程中至少要有一个线程。当然可以有多个线程
• 线程是cpu进行调度执行的最小单位
线程特点
　• 轻量级进程
　• 独立调度的基本单位
　• 可并发执行
　• 共享进程资源
线程和进程的区别

Thread类常用方法

2、线程的创建和启动
线程的创建
• 方式1：继承Java.lang.Thread类，重写run() 方法
• 方式2：实现Java.lang.Runnable接口，并实现run() 方法
• 方式3：JUC并发包下,实现Callable。JDK1.5 出现的。
• 方法run( )称为线程体。
线程的启动
• 新建的线程不会自动开始运行，必须通过start( )方法启动
• 不能直接调用run()来启动线程，这样run()将作为一个普通方法立即执行，执行完毕前其他线程无法并发法执行。
• Java程序启动时，会立刻创建主线程，main就是在这个线程上运行。当不再产生新线程时，程序是单线程的。
第一种方式创建线程：

1、创建：Thread + 重写run
2、启动：创建子类对象 + start()

// 继承Thread类
public class StartThread extends Thread {
    // 重写了run方法
    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println("一边听音乐");
        }
    }
    public static void main(String[] args) {
        // 创建子类对象
        StartThread thread = new StartThread();
        // 启动线程
        thread.start();// 不保证CPU立即调用
        // thread.run();// 调用普通方法，不管怎么运行：必须听完音乐才能敲代码
        for (int i = 0; i < 5; i++) {
            System.out.println("一边敲代码");
        }
    }
}

第二种方式创建线程：
1、创建：实现Runnable接口 + 重写run
2、启动：创建实现类对象 + Thread对象 + start()

// 实现Runnable接口
public class StartRun implements Runnable {
    // 重写了run方法,线程的入口点
    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println("一边听音乐");
        }
    }
    public static void main(String[] args) {
        /*// 创建实现类对象
        StartRun sr = new StartRun();
        // 创建代理类对象
        Thread t = new Thread(sr);
        // 启动
        t.start();*/

        // 可简写为
        new Thread(new StartRun()).start();


        // thread.run();// 调用普通方法，不管怎么运行：必须听完音乐才能敲代码
        for (int i = 0; i < 5; i++) {
            System.out.println("一边敲代码");
        }
    }
}

两种线程创建方式的比较
• 继承Thread类方式的多线程
　• 优势：编写简单
　• 劣势：无法继承其它父类
• 实现Runnable接口方式的多线程
　• 优势：可以继承其它类，多线程可共享同一个Runnable对象
　• 劣势：编程方式稍微复杂，如果需要访问当前线程，需要调用Thread.currentThread()方法
一般Runnable接口方式要优先使用。
example【模拟抢票】

package boom.thread;
/**
 * 共享资源：模拟抢票[会出现线程安全]
 * @author Administrator
 *
 */
public class Web12306 implements Runnable{
    // 余票
    private int ticketNums = 100;
    
    @Override
    public void run() {
        while(true){
            if(ticketNums < 0){
                break;
            }
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            // Thread.currentThread().getName() 当前线程名称
            System.out.println(Thread.currentThread().getName() + "--->" + ticketNums--);
        }
    }
    public static void main(String[] args) {
        // 一份资源
        Web12306 web12306  =new Web12306();
        System.out.println(Thread.currentThread().getName());
        // 多个代理
        new Thread(web12306, "售票员-1").start();
        new Thread(web12306, "售票员-2").start();
        new Thread(web12306, "售票员-3").start();
        new Thread(web12306, "售票员-4").start();
        new Thread(web12306, "售票员-5").start();
    }
}

example【龟兔赛跑】

package boom.thread;

import java.io.Reader;

/**
 * 模拟龟兔赛跑
 * 
 * @author Administepsor
 *
 */
public class Racer implements Runnable {
    private static String winner;// 记录胜利者

    @Override
    public void run() {
        for (int steps = 1; steps <= 100; steps++) {
            // 模拟休息[兔子每走十步就休息100毫秒]
            if (Thread.currentThread().getName().equals("兔子") && steps % 10 == 0) {
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println(Thread.currentThread().getName() + "-->" + steps);
            // 比赛是否结束
            boolean flag = gameOver(steps);
            if (flag) {
                break;
            }
        }
    }

    // 比赛是否结束
    public boolean gameOver(int steps) {
        if (winner != null) {// 存在胜利者
            return true;
        } else {
            if (steps == 100) {
                winner = Thread.currentThread().getName();
                System.out.println("winner => " + winner);
            }
        }
        return false;
    }

    public static void main(String[] args) {
        Racer reader = new Racer();
        new Thread(reader, "乌龟").start();
        new Thread(reader, "兔子").start();
    }

}

第三种方式：实现Callable接口【先了解】
　• 与实行Runnable相比， Callable功能更强大些
　• 方法不同
　• 可以有返回值，支持泛型的返回值
　• 可以抛出异常
　• 需要借助FutureTask，比如获取返回结果
Future接口
　• 可以对具体Runnable、Callable任务的执行结果进行取消、查询是否完成、获取结果等。
　• FutrueTask是Futrue接口的唯一的实现类
　• FutureTask 同时实现了Runnable, Future接口。它既可以作为Runnable被线程执行，又可以作为Future得到Callable的返回值
example【改进龟兔赛跑】

package boom.thread;

import java.io.Reader;
import java.lang.reflect.Executable;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

/**
 * 模拟龟兔赛跑
 * 
 * @author Administepsor
 *
 */
public class Racer2 implements Callable<Integer> {
    private static String winner;// 记录胜利者

    @Override
    public Integer call() throws Exception {
        for (int steps = 1; steps <= 100; steps++) {
            // 模拟休息[兔子每走十步就休息100毫秒]
            if (Thread.currentThread().getName().equals("pool-1-thread-1") && steps % 10 == 0) {
                Thread.sleep(100);
            }
            System.out.println(Thread.currentThread().getName() + "-->" + steps);
            // 比赛是否结束
            boolean flag = gameOver(steps);
            if (flag) {
                return steps;
            }
        }
        return null;
    }

    // 比赛是否结束
    public boolean gameOver(int steps) {
        if (winner != null) {// 存在胜利者
            return true;
        } else {
            if (steps == 100) {
                winner = Thread.currentThread().getName();
                System.out.println("winner => " + winner);
                return true;
            }
        }
        return false;
    }

    public static void main(String[] args) throws InterruptedException, ExecutionException {
        Racer2 reader = new Racer2();

        // 创建执行服务
        ExecutorService ser = Executors.newFixedThreadPool(2);
        // 提交执行
        Future<Integer> result1 = ser.submit(reader);
        Future<Integer> result2 = ser.submit(reader);
        // 获取结果
        Integer integer1 = result1.get();
        Integer integer2 = result2.get();
        System.out.println(integer1 + "-->" + integer2);
        // 关闭服务
        ser.shutdownNow();
    }

}

简单的静态代理设计模式

package boom.thread;

public class StaticProxy {
    public static void main(String[] args) {
        // new 子类对象传入真是角色在.具体实现方法
        new WeddingCompany(new You()).happyMarry();
    }
}
// 定义抽象类
interface Marry{
    // 实现抽象方法
    void happyMarry();
}
// 真实角色继承了抽象类
class You implements Marry{
    // 重写抽象类的抽象方法
    @Override
    public void happyMarry() {
        System.out.println("我们终于结婚了!!");
    }
}
// 代理角色[婚庆公司]
class WeddingCompany implements Marry{
    // 真实角色
    private Marry flag;
    // 带参构造方法
    public WeddingCompany(Marry flag) {
        this.flag = flag;
    }

    @Override
    public void happyMarry() {
        ready();
        this.flag.happyMarry();
        affter();
    }

    private void ready() {
        System.out.println("在路上！");
    }
    
    private void affter() {
        System.out.println("民政局拿小本本！!！");
    }
}

3、线程的生命周期[线程的五大状态]

新生状态：
　• 用new关键字建立一个线程对象后，该线程对象就处于新生状态。
　• 处于新生状态的线程有自己的内存空间，通过调用start进入就绪状态
就绪状态：
　• 处于就绪状态线程具备了运行条件，但还没分配到CPU，处于线程就绪队列，等待系统为其分配CPU
　• 当系统选定一个等待执行的线程后，它就会从就绪状态进入执行状态，该动作称之为“cpu调度”。
运行状态：
　• 在运行状态的线程执行自己的run方法中代码，直到等待某资源而阻塞或完成任务而死亡。
　• 如果在给定的时间片内没有执行结束，就会被系统给换下来回到等待执行状态。
阻塞状态：
　　• 处于运行状态的线程在某些情况下，如执行了sleep（睡眠）方法，或等待I/O设备等资源，将让出CPU并暂时停止自己的运行，进入阻塞状态。
　　• 在阻塞状态的线程不能进入就绪队列。只有当引起阻塞的原因消除时，如睡眠时间已到，或等待的I/O设备空闲下来，线程便转入就绪状态，重新到就绪队列中排队等待，被系统选中后从原来停止的位置开始继续运行。
死亡状态：
　• 死亡状态是线程生命周期中的最后一个阶段。线程死亡的原因有三个。一个是正常运行的线程完成了它的全部工作；另一个是线程被强制性地终止，如通过执行stop方法来终止一个线程[不推荐使用】，三是线程抛出未捕获的异常.

4、线程的控制方法
·sleep()
　·使线程停止运行一段时间，将处于阻塞状态
　·如果调用了sleep方法之后，没有其他等待执行的线程，这个时候当前线程不会马上恢复执行！
·join()
　·阻塞指定线程等到另一个线程完成以后再继续执行。
·yield()
　·让当前正在执行线程暂停，不是阻塞线程，而是将线程转入就绪状态；等待cpu调度器重新调度
　·调用了yield方法之后，如果没有其他等待执行的线程，此时当前线程就会马上恢复执行！
·setDaemon()
　·可以将指定的线程设置成后台线程，守护线程；
　·创建用户线程的线程结束时，后台线程也随之消亡；
　·只能在线程启动之前把它设为后台线程
·setPriority（int newPriority）getPriority()
　·线程的优先级代表的是概率·范围从1到10，默认为5
·stop()停止线程 不推荐使用
详细介绍线程控制方法：
1：stop()终止线程方式：
* 1、线程正常执行完毕
* 2、外部加入标识，不使用stop，destroy【线程不安全】

package boom.thread.state;

/**
 * 终止线程的两种方法： 1、线程正常执行完毕 2、外部加入标识，不使用stop，destroy。
 * 
 * @author Administrator
 *
 */
public class TerminateThread implements Runnable {
    // 1、加入标识，标记线程体是否可以运行
    private boolean flag = true;
    private String name;

    public TerminateThread(String name) {
        this.name = name;
    }

    @Override
    public void run() {
        int i = 0;
        // 2、关联标识 true--> 运行，false --> 终止
        while (flag) {
            System.out.println(name + "-->" + i++);
        }
    }

    // 3、对外提供方法改变标识
    public void terminate() {
        this.flag = false;
    }

    public static void main(String[] args) {
        TerminateThread thread = new TerminateThread("阿甘");
        new Thread(thread).start();

        for (int i = 0; i < 100; i++) {
            if (i == 66) {
                thread.terminate();// 线程终止
                System.out.println("thread over");
            }
            System.out.println("main=>" + i);
        }
    }

}

2：sleep()【火车票模拟延时】
sleep（时间）指定当前线程阻塞的毫秒数；
sleep存在异常InterruptedException；
sleep时间达到后线程进入就绪状态；
sleep可以模拟网络延时、倒计时等。
每一个对象都有一个锁，sleep不会释放锁；

package boom.thread.state;

public class BlockedSleep {

    public static void main(String[] args) {
        TicketSystem ts = new TicketSystem();
        new Thread(ts, "售票员 - 1").start();
        new Thread(ts, "售票员 - 2").start();
        new Thread(ts, "售票员 - 3").start();
        new Thread(ts, "售票员 - 4").start();
        new Thread(ts, "售票员 - 5").start();
        new Thread(ts, "售票员 - 6").start();
    }

}
class TicketSystem implements Runnable{
    private int ticketNums = 99;
    
    @Override
    public void run() {
        while(true){
            if(ticketNums < 0){
                break;
            }
            // 模拟延时
            try {
                Thread.sleep(200);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "=>" + ticketNums--);
        }
            
    }
}

模拟倒计时：

public static void main(String[] args) throws InterruptedException {
    int num = 10;
    while(true) {
        if(num == 0) {
            System.out.println("点火");
            break;
        }
        Thread.sleep(1000);
        System.out.println("倒计时 --> " + num--);
    }
}

3：yield()：让出CPU的调度，暂停线程，进入就绪状态，并不是阻塞状态.

MyYield myYield = new MyYield();
new Thread(myYield, "国产001").start();
new Thread(myYield, "国产002").start();

/*---------------------------------------------------------------*/

class MyYield implements Runnable {
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + "--> start");
        Thread.yield();// 礼让【重回调度器里等待调度。可能礼让成功，可能调度到自己】
        System.out.println(Thread.currentThread().getName() + "--> end");

    }
}

 4：join()：可理解为插队线程

package boom.thread.state;

public class JoinDemo {

    public static void main(String[] args) {
        System.out.println("/-------买酱油的的故事-------/");
        new Thread(new Father()).start();
    }

}
class Father extends Thread{
    @Override
    public void run() {
        System.out.println("炒菜呢，发现酱油没了,让儿子去买酱油");
        Thread thread = new Thread(new Son());
        thread.start();
        try {
            thread.join();// father被阻塞
            System.out.println("接过酱油，继续炒菜");
        } catch (InterruptedException e) {
            e.printStackTrace();
            System.out.println("孩子走丢了");
        }
    }
}
class Son extends Thread{
    @Override
    public void run() {
        System.out.println("接过钱去买酱油，发现路边有游戏厅去玩了一会");
        for(int i = 0;i<4;i++){
            System.out.println(i + "秒过去...");
            
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println("想起来买酱油，去买酱油");
        System.out.println("买好后回来了。");
    }
}

5、线程的优先级
Java提供一个线程调度器来监控程序中启动后进入就绪状态的所有线程。线程调度器按照线程的优先级决定应调度哪个线程来执行。
线程的优先级用数字表示，范围从1到10
• Thread.MIN_PRIORITY = 1
• Thread.MAX_PRIORITY = 10
• Thread.NORM_PRIORITY = 5【默认】
使用下述方法获得或设置线程对象的优先级。
• int getPriority(); 返回线程的优先级。
• void setPriority(int newPriority); 更改线程的优先级。
注意：优先级低只是意味着获得调度的概率低。并不是绝对先调用优先级高的，再调用优先级低的线程。

package boom.thread.state;

/**
 * 线程的优先级:优先级低只是意味着获得调度的概率低,比不是优先级高的就决定的先调用
 * 
 * @author Administrator
 *
 */
public class PriorityDemo {

    public static void main(String[] args) {
        System.out.println(Thread.currentThread().getName() + "-->" + Thread.currentThread().getPriority());
        MyPriority priority = new MyPriority();
        
        Thread thread_1 = new Thread(priority, "百度");
        Thread thread_2 = new Thread(priority, "阿里");
        Thread thread_3 = new Thread(priority, "腾讯");
        Thread thread_4 = new Thread(priority, "Google");
        Thread thread_5 = new Thread(priority, "网易");
        Thread thread_6 = new Thread(priority, "网景");
        
        // 启动前设置优先级
        thread_1.setPriority(Thread.MAX_PRIORITY);
        thread_3.setPriority(Thread.MAX_PRIORITY);
        thread_5.setPriority(Thread.MAX_PRIORITY);
        thread_6.setPriority(Thread.MIN_PRIORITY);
        
        thread_1.start();
        thread_2.start();
        thread_3.start();
        thread_4.start();
        thread_5.start();
        thread_6.start();

    }

}

class MyPriority implements Runnable {
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + "-->" + Thread.currentThread().getPriority());
    }
}

守护线程：是为用户线程服务的；jvm停止不用等待守护线程执行完毕。默认的线程【用户线程】:JVM等待用户线程执行完毕才会停止。
·线程分为用户线程和守护线程；
·虚拟机必须确保用户线程执行完毕；
·虚拟机不用等待守护线程执行完毕；
·如后台记录操作日志、监控内存使用等。

package boom.thread.state;

/**
 * 守护线程：是为用户线程服务的；jvm停止不用等待守护线程执行完毕
 * 
 * @author Administrator
 *
 */
public class DaemonTest {

    public static void main(String[] args) {
        God god = new God();
        Person Person = new Person();
        Thread thread = new Thread(god, "上帝");
        thread.setDaemon(true);// 默认为false，设置用户线程为守护线程，值true
        thread.start();
        new Thread(Person, "Person").start();
        
    }

}

class Person implements Runnable {
    // 人类的视角是普遍是一个世纪的年华
    @Override
    public void run() {
        for (int i = 0; i < 365 * 100; i++) {
            System.out.println(Thread.currentThread().getName() + ":" + "happy life……");
        }
        System.out.println(Thread.currentThread().getName() + ":" + "Game Over……");
    }
}

class God implements Runnable {
    // 上帝的视角是无生命周期的死循环
    @Override
    public void run() {
        while (true) {
            System.out.println(Thread.currentThread().getName() + ":" + "bless Person……");
        }
    }
}

线程不安全的三大经典案例：【线程不安全会出现数据产生负数或者出现相同的值】
买票

package boom.thread.syn;
/**
 * 线程不安全：数据出现负数或者出现相同的数据
 * @author Administrator
 *
 */
public class Unsafe {

    public static void main(String[] args) {
        Unsafe12306 safe = new Unsafe12306();
        new Thread(safe, "[售票员]-1").start();
        new Thread(safe, "[售票员]-2").start();
        new Thread(safe, "[售票员]-3").start();

    }

}

class Unsafe12306 implements Runnable {
    private int ticketNums = 10;
    private boolean flag = true;

    @Override
    public void run() {
        while (flag) {
            test();
        }
    }

    private void test() {
        if (ticketNums < 0) {
            flag = false;
            return;
        }
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + "-->" + ticketNums--);
    }

}

取钱

package boom.thread.syn;

/**
 * 线程不 安全：取钱问题
 * 
 * @author Administrator
 *
 */
public class Unsafe2 {

    public static void main(String[] args) {
        // 账户
        Account account = new Account(100, "小金库总额");
        Drawing you = new Drawing(account, 80, "可悲的你");
        Drawing wife = new Drawing(account, 90, "happy的她");
        you.start();
        wife.start();
    }

}

// 账户
class Account {
    int money;// 金额
    String name;// 名称

    public Account(int money, String name) {
        this.money = money;
        this.name = name;
    }
}

// 模拟取款
class Drawing extends Thread {
    Account account;// 取钱的账户
    int drawingMoney;// 取钱的金额
    int packetTotal;// 口袋里的钞票

    public Drawing(Account account, int drawingMoney, String name) {
        super(name);
        this.account = account;
        this.drawingMoney = drawingMoney;
    }

    @Override
    public void run() {
        // 如果账户的钱 - 要取的钱< 0;直接结束
        if(account.money - drawingMoney < 0){
            return;
        }
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        // 账户的里钱=账户总额- 要取的钱
        account.money -= drawingMoney;
        packetTotal += drawingMoney;
        System.out.println(this.getName() + "-->口袋里的钱：" + packetTotal);
        System.out.println(this.getName() + "-->账户余额：" + account.money);
    }

}

操作容器

package boom.thread.syn;

import java.util.ArrayList;
import java.util.List;

/**
 * 线程不安全：操作容器
 * @author Administrator
 *
 */
public class Unsafe3 {

    public static void main(String[] args) {
        List<String> list = new ArrayList<String>();
        for(int i = 0; i <100;i++){
            new Thread(()->{
                list.add(Thread.currentThread().getName());
            }).start();
        }
        System.out.println(list.size());
    }

}

6、多线程_并发_同步_队列与锁
并发：同一个对象被多个线程同时访问。
线程同步
　　处理多线程问题时，多个线程访问同一个对象，并且某些线程还想修改这个对象。这时候，我们就需要用到“线程同步”。线程同步其实就是一种等待机制，多个需要同时访问此对象的线程进入这个对象的等待池形成队列，等待前面的线程使用完毕后，下一个线程再使用。
　　当多个线程访问同一个数据时，容易出现线程安全问题。需要让线程同步，保证数据安全。当两个或两个以上线程访问同一资源时，需要某种方式来确保资源在某一时刻只被一个线程使用。
　　为了保证数据在方法中被访问时的正确性，在访问时加入锁机制（synchronized），当一个线程获得对象的排它锁，独占资源，其他线程必须等待，使用后释放锁即可存在以下问题：·
  一个线程持有锁会导致其它所有需要此锁的线程挂起；
  在多线程竞争下，加锁、释放锁会导致比较多的上下文切换和调度延时，引起性能问题；
  如果一个优先级高的线程等待一个优先级低的线程释放锁会导致优先级倒置，副起性能问题。
线程同步的实现方案
同步1代码块
　• synchronized (obj){ }
同步方法
　• private synchronized void makeWithdrawal(int amt) {}
并发_同步_synchronized方法
售票员买票

package boom.thread.syn;

/**
 * 线程安全：在并发时保证数据的正确性、效率尽可能的高 
 * synchronize 
 * [1、同步方法] 2、同步块
 * 
 * @author Administrator
 *
 */
public class SafeTest {

    public static void main(String[] args) {
        Ssafe12306 safe = new Ssafe12306();
        new Thread(safe, "[售票员]-1").start();
        new Thread(safe, "[售票员]-2").start();
        new Thread(safe, "[售票员]-3").start();

    }

}

class Ssafe12306 implements Runnable {
    private int ticketNums = 100;
    private boolean flag = true;

    @Override
    public void run() {
        while (flag) {
            test();
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    // 线程安全：synchronize同步方法,锁住的方法的对象资源
    private synchronized void test() {
        if (ticketNums <= 0) {
            flag = false;
            return;
        }
        try {
            Thread.sleep(200);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + "-->" + ticketNums--);
    }

}

error 取钱【锁定的目标出现也会出现线程的安全性问题】

package com.test;

/**
 * 线程安全：在并发时保证数据的正确性、效率尽可能的高 synchronize 1、同步方法 2、同步块
 * @author Administrator
 *
 */
public class TestCode {

    public static void main(String[] args) {
        // 账户
        Account account = new Account(100, "小金库总额");
        SafeDrawing you = new SafeDrawing(account, 80, "可悲的你");
        SafeDrawing wife = new SafeDrawing(account, 90, "happy的她");
        you.start();
        wife.start();
    }

}

// 账户
class Account {
    int money;// 金额
    String name;// 名称

    public Account(int money, String name) {
        this.money = money;
        this.name = name;
    }
}

// 模拟取款
class SafeDrawing extends Thread {
    Account account;// 取钱的账户
    int DrawingMoney;// 取钱的金额
    int packetTotal;// 口袋里的钞票

    public SafeDrawing(Account account, int DrawingMoney, String name) {
        super(name);
        this.account = account;
        this.DrawingMoney = DrawingMoney;
    }

    @Override
    public void run() {
        test();
    }

    // 锁定的目标不对，锁定的不是this，应该锁住account
    private synchronized  void test() {
        // 如果账户的钱 - 要取的钱< 0;直接结束
        if (account.money - DrawingMoney < 0) {
            return;
        }
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        // 账户的里钱=账户总额- 要取的钱
        account.money -= DrawingMoney;
        packetTotal += DrawingMoney;
        System.out.println(this.getName() + "-->口袋里的钱：" + packetTotal);
        System.out.println(this.getName() + "-->账户余额：" + account.money);
    }

}

并发_同步_synchronized块
同步块：synchronized（obj）{}，obi称之为同步监视器
　·obi可以是任何对象，但是推荐使用共享资源作为同步监视器
　·同步方法中无需指定同步监视器，因为同步方法的同步监视器是this即该对象本身，或class即类的模子
同步监视器的执行过程
　·第一个线程访问，锁定同步监视器，执行其中代码
　·第二个线程访问，发现同步监视器被锁定，无法访问
　·第一个线程访问完毕，解锁同步监视器
　·第二个线程访问，发现同步监视器未锁，锁定并访问
同步代码块【取钱，操作容器】
取钱

package com.test;
/**
 * 线程安全：在并发时保证数据的正确性、效率尽可能的高 synchronize 1、同步方法 [2、同步块]
 * 
 * @author Administrator
 *
 */
public class TestCode {

    public static void main(String[] args) {
        // 账户
        Account account = new Account(1000, "小金库总额");
        SynDrawing you = new SynDrawing(account, 80, "可悲的你");
        SynDrawing wife = new SynDrawing(account, 90, "happy的她");
        you.start();
        wife.start();
    }

}

// 账户
class Account {
    int money;// 金额
    String name;// 名称

    public Account(int money, String name) {
        this.money = money;
        this.name = name;
    }
}

// 模拟取款
class SynDrawing extends Thread {
    Account account;// 取钱的账户
    int DrawingMoney;// 取钱的金额
    int packetTotal;// 口袋里的钞票

    public SynDrawing(Account account, int DrawingMoney, String name) {
        super(name);
        this.account = account;
        this.DrawingMoney = DrawingMoney;
    }

    @Override
    public void run() {
        test();
    }

    // 锁定account
    private void test() {
        // 提高性能
        if (account.money == 0) {
            return;
        }
        // 同步代码块，锁住account
        synchronized (account) {
            // 如果账户的钱 - 要取的钱< 0;直接结束
            if (account.money - DrawingMoney < 0) {
                return;
            }
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            // 账户的里钱=账户总额- 要取的钱
            account.money -= DrawingMoney;
            packetTotal += DrawingMoney;
            System.out.println(this.getName() + "-->口袋里的钱：" + packetTotal);
            System.out.println(this.getName() + "-->账户余额：" + account.money);
        }
    }

}

操作容器

package boom.thread.syn;

import java.util.ArrayList;
import java.util.List;

/**
 * @author Administrator
 *
 */
public class SynBlock2 {

    public static void main(String[] args) throws InterruptedException {
        List<String> list = new ArrayList<String>();
        for (int i = 0; i < 1000; i++) {
            new Thread(() -> {
                synchronized (list) {
                    list.add(Thread.currentThread().getName());
                }
            }).start();
        }
        Thread.sleep(1000);
        System.out.println(list.size());
    }

}

死锁：某一个同步块同时拥有“两个以上对象的锁”时，就可能会发生“死锁”的问题。
　　　过多的同步可能造成互相不释放资源，从而相互等待，一般发生于同步中持有多个对象的锁。