1，线程安全
先看上一节程序，我们稍微改动一下：
//线程安全演示
//火车站有16张票，需要从四个窗口卖出，如果按照上面的多线程实现，程序如下
class Ticket implements Runnable
{
private int tick = 16;//票的张数---16
public void run(){
while(true){
if(tick>0){
//这里的sleep(100)是这次程序要表的关键，只是个模拟而已
try{
Thread.sleep(100);
}catch(Exception e){
}
System.out.println(Thread.currentThread().getName() + "...sale:" + tick--);
}
}
}
public static void main(String[] args)
{
Ticket t = new Ticket();
Thread t1 = new Thread(t);
Thread t2 = new Thread(t);
Thread t3 = new Thread(t);
Thread t4 = new Thread(t);
t1.start();
t2.start();
t3.start();
t4.start();
}
}
其他之处没有改变，只是在判断还有票之后立即睡眠一段时间，这在现实中有可能发生的，线程A刚执行到这里，突然cpu切换到其他线程B中，而B线程也刚好执行到判断语句又被A线程抢夺cpu，此时A线程不用再判断，直接输出，并修改ticket的值，此时有可能使得tickte>0不再满足，但是下一次B线程执行时，也不去判断tickte的值，导致出错。看看上面的程序结果（不为一），数了一下，打印了20张票，还有-1，-2，0的 情况，这就是线程安全问题了。
问题原因：当多条语句在操作同一个线程共享数据时，一个线程对多条语句只执行了一部分，还没有执行完另一个线程就来执行，导致共享数据的错误。
解决办法：对多条操作共享数据的语句，只能让一个线程都执行过程中，其他线程也不能执行。即使其他线程拿到执行权！这就是java提供的同步代码块方案。其格式如下：
synchronized(对象){
需要同步的代码块
}
分析：上面的synchronized后面的对象如同锁，也叫同步监视器，持有锁的线程可以同步执行，没有持有锁的线程即使获取cpu的执行权，也不能进不去同步代码块。线程开始执行同步代码块必须先对同步监视器的锁定。
同步前提：
（1）必须有两个或者两个以上的线程。
（2）必须是多个线程使用同一个锁。
任何时刻只有一个线程获得对同步监视器的锁定，当同步代码块执行结束时，该线程会释放对同步监视器的锁定。
如何看哪些代码需要同步？看看共享数据参与运算的范围。if(tick>0)，还有tick—；因此把上面程序改为如下：
//线程安全演示
//火车站有16张票，需要从四个窗口卖出，如果按照上面的多线程实现，程序如下
class Ticket implements Runnable
{
private int tick = 16;//票的张数---16
Object obj = new Object();
public void run(){
while(true){
synchronized(obj){
if(tick>0){
//这里的sleep(100)是这次程序要表的关键，只是个模拟而已
try{
Thread.sleep(10);
}catch(Exception e){
}
System.out.println(Thread.currentThread().getName() + "...sale:" + tick--);
}
}
}
}
public static void main(String[] args)
{
Ticket t = new Ticket();
Thread t1 = new Thread(t);
Thread t2 = new Thread(t);
Thread t3 = new Thread(t);
Thread t4 = new Thread(t);
t1.start();
t2.start();
t3.start();
t4.start();
}
}
此时运行就没有出现错误。结果就不展示了。
好处：解决线程安全问题
缺点：多线程需要判断锁，较为消耗资源
2，线程同步
再看下面的例子
/*
需求：银行有一个金库，有两个储户分别存入300元，都是分3次存入
目的：查看该程序是否有安全问题，如果有，如何解决？
如何找问题：
1，明确哪些代码是多线程运行代码
2，明确哪些是共享数据
3，明确哪些代码使用共享数据
*/
class Bank
{
//Object obj = new Object(); ------1
private int sum;
public synchronized void add(int n){ //synchronized可以放在此处作为同步函数
//synchronized(obj){ ------2
sum = sum + n;
try{
Thread.sleep(10);
}catch(Exception e){
}
System.out.println("sum = " + sum);
//} ------3
}
}
class Cus implements Runnable
{
private Bank b = new Bank();
public void run(){
for(int x = 0; x < 3; x++){
b.add(100);
}
}
}
class BankDemo
{
public static void main(String[] agrs){
Cus c = new Cus();
Thread t1 = new Thread(c);
Thread t2 = new Thread(c);
t1.start();
t2.start();
}
}
上面代码如果不同步就会出现线程安全问题，但是同步不止刚才那种同步代码块，还有同步函数可以使用，本程序就是个例子。但是对于卖票那个程序来试试
//线程安全演示
//火车站有16张票，需要从四个窗口卖出，如果按照上面的多线程实现，程序如下
class Ticket implements Runnable
{
private int tick = 160;//票的张数---160
//Object obj = new Object();
public synchronized void run(){
while(true){
//synchronized(obj){
if(tick>0){
//这里的sleep(1000)是这次程序要表的关键，只是个模拟而已
try{
Thread.sleep(100);
}catch(Exception e){
}
System.out.println(Thread.currentThread().getName() + "...sale:" + tick--);
}
//}
}
}
public static void main(String[] args)
{
Ticket t = new Ticket();
Thread t1 = new Thread(t);
Thread t2 = new Thread(t);
Thread t3 = new Thread(t);
Thread t4 = new Thread(t);
t1.start();
t2.start();
t3.start();
t4.start();
}
}
结果
其实这里面一直是线程0在执行，因为run方法是在同步，当0线程执行时别的线程都不能执行，这是因为同步的代码块范围不正确，只需要把需要同步的代码块封装为一个函数，便可以在run方法中调用这个函数即可。
//线程安全演示
//火车站有16张票，需要从四个窗口卖出，如果按照上面的多线程实现，程序如下
class Ticket implements Runnable
{
private int tick = 160;//票的张数
public void run(){
while(true){
show();//此处调用show方法
}
}
public synchronized void show(){//将同步代码块封装起来
if(tick>0){
try{
Thread.sleep(100);
}catch(Exception e){
}
System.out.println(Thread.currentThread().getName() + "...sale:" + tick--);
}
}
public static void main(String[] args)
{
Ticket t = new Ticket();
Thread t1 = new Thread(t);
Thread t2 = new Thread(t);
Thread t3 = new Thread(t);
Thread t4 = new Thread(t);
t1.start();
t2.start();
t3.start();
t4.start();
}
}
此时可以看到几个线程都启动了。那么有个疑问，同步代码块这种方法有个同步监视器来进行锁住。那么同步方法怎么实现呢？
其实函数都需要对象调用，每个函数都有一个对象引用，就是隐含的this，所以同步函数使用的锁就是this。
通过程序来验证：
使用两个线程来实现卖票，第一个线程在同步函数中，第二个线程在同步代码块中。都在执行卖票动作。
class Ticket implements Runnable
{
private int tick = 16;//票的张数
Object obj = new Object();
boolean flag = true;
public void run(){
if(flag){
while(true){
synchronized(obj){
if(tick>0){
try{
Thread.sleep(100);
}catch(Exception e){
}
System.out.println(Thread.currentThread().getName() + "...code:" + tick--);
}
}
}
}
else{
while(true){
show();
}
}
}
public synchronized void show(){
if(tick>0){
try{
Thread.sleep(100);
}catch(Exception e){
}
System.out.println(Thread.currentThread().getName() + "...show:" + tick--);
}
}
public static void main(String[] args)
{
Ticket t = new Ticket();
Thread t1 = new Thread(t);
Thread t2 = new Thread(t);
t1.start();
try{
Thread.sleep(100);
}catch(Exception e){
}
t.flag = false;
t2.start();
}
}
结果如下
先来解释一下，这个程序的run()方法中有同步代码块，还有一个同步函数。我们的意思是想让t1先执行，在main函数中让其sleep是因为如果没有sleep的话，主线程可能没有分配给t1的cpu执行权直接执行下面的flag = false这句，导致同步代码块中的代码永远不能执行。加入sleep可以执行同步代码块的代码，也可以执行同步函数中的代码，但是看到结果，打印了0号票，这是不允许的，是什么造成了这种情况？
看看文章最前面的同步的前提，有两个，再次提出：
（1）必须有两个或者两个以上的线程。-----满足
（2）必须是多个线程使用同一个锁。-----不满足-----〉第一个锁是synchronized(obj)中的obj，还有一个同步函数，它的锁是this，就是调用它的对象。
把synchronized(obj)这句换为synchronized(this),就不会出现上述问题，所以这样满足第二个前提，说明同步函数使用的的确是this这个锁。
有个情况，如果同步函数使用static修饰，那么静态方法中的锁是谁呢？肯定不是this，因为静态方法没有this。静态进内存时没有本类对象，但是有本类的字节码对象，该对象的类型是class.因此，对于静态方法，他的同步监视器（也就是锁）就是类名.class。把synchronized(obj)这句换为synchronized(Ticket.class),就不会出现0号票了。
3，死锁
死锁原因：同步中嵌套同步，但是锁却不同步。
先修改上面的程序
class Ticket implements Runnable
{
private int tick = 1000;//票的张数
Object obj = new Object();
boolean flag = true;
public void run(){
if(flag){
while(true){
synchronized(obj){
System.out.println("*****************");
show();
}
}
}
else{
while(true){
System.out.println("------------------");
show();
}
}
}
public synchronized void show(){
synchronized(obj){
if(tick>0){
try{Thread.sleep(10);}catch(Exception e){}
System.out.println(Thread.currentThread().getName() + "...code:" + tick--);
}
}
}
public static void main(String[] args)
{
Ticket t = new Ticket();
Thread t1 = new Thread(t);
Thread t2 = new Thread(t);
t1.start();
try{Thread.sleep(100);}catch(Exception e){}
t.flag = false;
t2.start();
}
}
上面的程序出现死锁，原因是同步代码块中锁是obj，且嵌套同步函数（其锁是this），同步函数的锁是this，而其中又嵌套同步代码块，其锁是obj。可以修改锁即可。比如把obj全部换为this。这样代码就不会出错。但上述代码的输出-----和***之前加入一句判断语句if(tick>0)不然票卖完了还在打印。
上面的例子是同步代码块中包含同步函数，同步函数中又包含同步代码块，下面再看一个只在同步代码块中出现的死锁的例子。
class Test implements Runnable
{
private boolean flag;
Test(boolean flag){
this.flag = flag;
}
public void run(){
if(flag){
synchronized(MyLock.locka){
System.out.println("if a");
synchronized(MyLock.lockb){
System.out.println("if b");
}
}
}
else{
synchronized(MyLock.lockb){
System.out.println("else b");
synchronized(MyLock.locka){
System.out.println("else a");
}
}
}
}
}
class MyLock
{
static Object locka = new Object();
static Object lockb = new Object();
}
class DeadLockTest
{
public static void main(String[] agrs){
Thread t1 = new Thread(new Test(true));
Thread t2 = new Thread(new Test(false));
t1.start();
t2.start();
}
}
结合代码，在run()方法中，if语句中的同步代码块有嵌套，else也一样。他们也是这种情况：同步中嵌套同步，但是锁却不同步。
所以在以后的编程过程中一定要防止此类情况的发生。
注：这些代码和相关结论参见毕向东的java基础视频教程和李刚的《疯狂java讲义》，都非常不错！