虽然在工作过程中没有涉及到多线程的逻辑，所以此文参照五月的仓颉的博客在此整理JAVA多线程的知识点。
多线程的安全问题：
脏读
一个常见的概念。在多线程中，难免会出现在多个线程中对同一个对象的实例变量进行并发访问的情况，如果不做正确的同步处理，那么产生的后果就是"脏读"，也就是取到的数据其实是被更改过的。
比如最常见的好几个窗口卖火车票的问题，比如三个窗口同时销售10张火车票，火车票数应该根据实际的卖票数进行减数。
可以使用同步锁来作处理。
一、使用synchronized块
package epm.am.demo.utils;
public class Station extends Thread {
//通过构造方法给线程名字赋值
public Station(String name) {
super(name);// 给线程名字赋值
}
//为了保持票数的一致，票数要静态
static int tick = 20;
//创建一个静态钥匙
static Object ob = "aa";//值是任意的
//重写run方法，实现买票操作
@Override
public void run() {
while (tick > 0) {
synchronized (ob) {// 这个很重要，必须使用一个锁，
// 进去的人会把钥匙拿在手上，出来后才把钥匙拿让出来
if (tick > 0) {
System.out.println(getName() + "卖出了第" + tick + "张票");
tick--;
} else {
System.out.println("票卖完了");
}
}
try {
sleep(1000);//休息一秒
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
/**
* java多线程同步锁的使用
* 示例：三个售票窗口同时出售10张票
* */
public static void main(String[] args) {
//实例化站台对象，并为每一个站台取名字
Station station1=new Station("窗口1");
Station station2=new Station("窗口2");
Station station3=new Station("窗口3");
// 让每一个站台对象各自开始工作
station1.start();
station2.start();
station3.start();
}
}console_show:
窗口1卖出了第20张票
窗口2卖出了第19张票
窗口3卖出了第18张票
窗口3卖出了第17张票
窗口1卖出了第16张票
窗口2卖出了第15张票
窗口1卖出了第14张票
窗口3卖出了第13张票
窗口2卖出了第12张票
窗口1卖出了第11张票
窗口2卖出了第10张票
窗口3卖出了第9张票
窗口1卖出了第8张票
窗口2卖出了第7张票
窗口3卖出了第6张票
窗口1卖出了第5张票
窗口3卖出了第4张票
窗口2卖出了第3张票
窗口1卖出了第2张票
窗口2卖出了第1张票
票卖完了
二、使用synchronized方法
package epm.am.demo.utils;
public class ThreadDomain13 {
private int num = 0;
public void addNum(String userName)
{
System.out.println("userName:"+userName);
try
{
if ("a".equals(userName))
{
num = 100;
System.out.println("a顾客已经付钱了!");
Thread.sleep(2000);
}
else
{
num = 200;
System.out.println("b顾客已经付钱了!");
}
System.out.println(userName + " 顾客num = " + num + "元");
}
catch (InterruptedException e)
{
e.printStackTrace();
}
}
public static void main(String[] args)
{
ThreadDomain13 td = new ThreadDomain13();
MyThread13_0 mt0 = new MyThread13_0(td);
MyThread13_1 mt1 = new MyThread13_1(td);
mt0.start();
mt1.start();
}
}package epm.am.demo.utils;
public class MyThread13_0 extends Thread {
private ThreadDomain13 td;
public MyThread13_0(ThreadDomain13 td)
{
System.out.println("建立对象A");
this.td = td;
}
public void run()
{
System.out.println("调用runA");
td.addNum("a");
}
}package epm.am.demo.utils;
public class MyThread13_1 extends Thread {
private ThreadDomain13 td;
public MyThread13_1(ThreadDomain13 td)
{
this.td = td;
}
public void run()
{
td.addNum("b");
}
}console_show:
建立对象A
调用runA
userName:a
userName:b
a顾客已经付钱了!
b顾客已经付钱了!
b 顾客num = 200元
a 顾客num = 200元
由上述的结果可以看出：本来按照逻辑应该打印出a顾客付钱100元，但是实际结果并不是这样，这是线程安全问题。
1. mt0先运行，再赋值“a”，之后开始sleep；
2. mt0线程sleep的2秒时间里，mt1线程已经开始运行了，赋值b，把num赋值为200，并打印出b用了‘200’元；
3. mt0 sleep完毕后，num已经被赋值为200，所以打印出‘a 顾客num = 200元’。
为了解决此问题，可以在方法中加sychronized同步锁。
代码如下：
package epm.am.demo.utils;
public class ThreadDomain13 {
private int num = 0;
public synchronized void addNum(String userName)
{
System.out.println("userName:"+userName);
try
{
if ("a".equals(userName))
{
num = 100;
System.out.println("a顾客已经付钱了!");
Thread.sleep(2000);
}
else
{
num = 200;
System.out.println("b顾客已经付钱了!");
}
System.out.println(userName + " 顾客num = " + num + "元");
}
catch (InterruptedException e)
{
e.printStackTrace();
}
}
public static void main(String[] args)
{
ThreadDomain13 td = new ThreadDomain13();
MyThread13_0 mt0 = new MyThread13_0(td);
MyThread13_1 mt1 = new MyThread13_1(td);
mt0.start();
mt1.start();
}
}console_show:
情况一：
建立对象A
调用runA
userName:a
a顾客已经付钱了!
a 顾客num = 100元
userName:b
b顾客已经付钱了!
b 顾客num = 200元情况二：
建立对象A
userName:b
b顾客已经付钱了!
b 顾客num = 200元
调用runA
userName:a
a顾客已经付钱了!
a 顾客num = 100元
多个对象多个锁
public static void main(String[] args)
{
//ThreadDomain13 td = new ThreadDomain13();
ThreadDomain13 td0 = new ThreadDomain13();
ThreadDomain13 td1 = new ThreadDomain13();
MyThread13_0 mt0 = new MyThread13_0(td0);
MyThread13_1 mt1 = new MyThread13_1(td1);
mt0.start();
mt1.start();
}
}把上述main函数中的方法改成多个线程对象。
那么输出为
建立对象A
调用runA
userName:a
userName:b
a顾客已经付钱了!
b顾客已经付钱了!
b 顾客num = 200元
a 顾客num = 100元
原因其实很简单，
这里有一个重要的概念。关键字synchronized取得的锁都是对象锁，而不是把一段代码或方法（函数）当作锁，哪个线程先执行带synchronized关键字的方法，哪个线程就持有该方法所属对象的锁，其他线程都只能呈等待状态。但是这有个前提：既然锁叫做对象锁，那么势必和对象相关，所以多个线程访问的必须是同一个对象。
如果多个线程访问的是多个对象，那么Java虚拟机就会创建多个锁，就像上面的例子一样，创建了两个ThreadDomain13对象，就产生了2个锁。既然两个线程持有的是不同的锁，自然不会受到"等待释放锁"这一行为的制约，可以分别运行addNum(String userName)中的代码。
