线程同步问题：
假设有一个数x=1000,有两个线程，一个给x加一操作、另一个给x减一操作，
那么在执行n次之后，讲道理x应该还是等于1000的，但是因为线程同步的问题，最后会出现x!=1000的情况。
线程同步问题产生的原因：
1. 假设增加线程先进入，得到的x是1000
2. 进行增加运算
3. 正在做增加运算的时候，还没有来得及修改hp的值，减少线程来了
4. 减少线程得到的hp的值也是1000
5. 减少线程进行减少运算
6. 增加线程运算结束，得到值1001，并把这个值赋予x
7. 减少线程也运算结束，得到值999，并把这个值赋予x
这样x的值最后就是999
这种情况的x的值999就是一个错误的值，在业务上称之为脏数据
同步问题解决的思路：
假如先进行增加操作，增加线程获得x的值并进行增加操作，在完成整个增加操作之前，如果有
减少线程试图对x进行操作，但是不被允许那么增加操作完成之后，减少操作才能访问x的值，这
样就能避免上面的脏数据问题。
synchronized同步对象概念：
只要被我synchronized修饰的对象someObject，那有其他线程试图来占有someObject的时候，就会
等待，等我释放占有之后，其他线程才能有资格操作someObject。
someObject又叫做同步对象，任何对象都能作为同步对象，为了实现同步操作，必须使用同一个对象，
所以这里的someObject是一个（Object）类型的，啥都能使用它。
final Object someObject = new Object();释放同步对象的方式：synchronized代码块运行结束，或者有异常抛出。
Thread t1 = new Thread(){
public void run(){
try {
System.out.println( now()+" t1 线程已经运行");
System.out.println( now()+this.getName()+ " 试图占有对象：someObject");
synchronized (someObject) {
System.out.println( now()+this.getName()+ " 占有对象：someObject");
Thread.sleep(5000);
System.out.println( now()+this.getName()+ " 释放对象：someObject");
}
System.out.println(now()+" t1 线程结束");
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
};如果所有线程都访问的同一个对象的话，就可以用该对象来代替someObject。因为所有对象都可以作为同步对象。
也可以在方法前直接加上synchronized，那么在外部访问此方法的时候，就不需要格外使用synchronized了，
同样也达到了同步的效果。
public void hurt(){
//使用this作为同步对象
synchronized (this) {
hp=hp-1;
}
}线程安全的类：
HashMap和Hashtable都实现了Map接口，都是键值对保存数据的方式：
区别1、HashMap可以存放null，Hashtable不能存放null。
区别2、HashMap不是线程安全的类，Hashtable是线程安全的类。
Stringbuffer是线程安全的，StringBuilder不是线程安全的。
（线程安全的stringbuffer会更慢一点点，因为不需要同步，大家都抢着来，就很快）
ArrayList是非线程安全的，Vector不是线程安全的。
除此之外，Collections工具类里面有把上述非线程安全的类转换为线程安全的，比如以ArrayList为例：
package multiplethread;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
public class TestThread {
public static void main(String[] args) {
List<Integer> list1 = new ArrayList<>();
List<Integer> list2 = Collections.synchronizedList(list1);
}
}线程死锁：
死锁是在上面讲的线程占有的基础上的，
假设有a，b，c三个对象，t1,t2,t3三个线程，
当t1占有a时，接着想去占有b
同时当t2占有b时,接着想去占有c
同时当t3占有c时，接着想去占有a
但是呢，他们都是想去占有的状态，而自身占有的并没有解除，那这三线程就等，疯狂的等。
这就是线程死锁。
package Multiplethread;
import charactor.Hero;
public class Deadlock {
/*
* 3个同步对象a, b, c
3个线程 t1,t2,t3
故意设计场景，使这3个线程彼此死锁
*/
public static void main(String[] args) {
final Hero a=new Hero();
final Hero b=new Hero();
final Hero c=new Hero();
a.name="a";
b.name="b";
c.name="c";
Thread t1 = new Thread() {
public void run() {
synchronized (a) {
System.out.println("我是线程t1，我已经占有了a");
try {
Thread.sleep(1000);
}catch(InterruptedException e)
{
e.printStackTrace();
}
System.out.println("我想要占有b");
System.out.println("t1等待中");
synchronized (b) {
System.out.println("占有成功！");
}
}
}
};
t1.start();
Thread t2 = new Thread() {
public void run() {
synchronized (b) {
System.out.println("我是线程t2，我已经占有了b");
try {
Thread.sleep(1000);
}catch(InterruptedException e)
{
e.printStackTrace();
}
System.out.println("我想要占有c");
System.out.println("t2等待中");
synchronized (c) {
System.out.println("占有成功！");
}
}
}
};
t2.start();
Thread t3 = new Thread() {
public void run() {
synchronized (c) {
System.out.println("我是线程t3，我已经占有了c");
try {
Thread.sleep(1000);
}catch(InterruptedException e)
{
e.printStackTrace();
}
System.out.println("我想要占有a");
System.out.println("t3等待中");
synchronized (a) {
System.out.println("占有成功！");
}
}
}
};
t3.start();
}
}
线程交互：
在上述的过程中，线程和线程之间都是自己干自己的，要么一起争活干，要么就等别人做完才能干。
那么线程交互作用就是，让线程之间能实现配合一起工作。
两个方法:
this.wate()让占用this的线程等待，并临时释放占用，别的线程能可以先来处理this。调用wait一定
要在synchronized块里面，否则会出错。
this.notify() 通知那些在等待this的线程可以重新开始工作了，不用等待了。
还有notifyAll() 意思是所有等待的可以开始了。
比如How2j上站长给出的列子：
