1.线程同步
关键字：synchronized
百度一下：synchronized 关键字，代表这个方法加锁,相当于不管哪一个线程（例如线程A），运行到这个方法时,都要检查有没有其它线程B（或者C、 D等）正在用这个方法(或者该类的其他同步方法)，有的话要等正在使用synchronized方法的线程B（或者C 、D）运行完这个方法后再运行此线程A,没有的话,锁定调用者,然后直接运行。它包括两种用法：synchronized 方法和 synchronized 块。
保证当前线程完整执行该方法后，才能由其他线程调用。
2.以银行存取款为例
public class Bank {
private String account;
private Integer balance;
public Bank(String account, Integer balance) {
this.account = account;
this.balance = balance;
}
public String getAccount() {
return account;
}
public void setAccount(String account) {
this.account = account;
}
public Integer getBalance() {
return balance;
}
public void setBalance(Integer balance) {
this.balance = balance;
}
@Override
public String toString() {
return "Bank{" +
"account='" + account + '\'' +
", balance=" + balance +
'}';
}
//存100
public void saveAccount(){ //加上延时，模拟更加真实
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
setBalance(this.getBalance()+100);
System.out.println("存款后："+getBalance());
}
public void drawAccount(){
Integer temp= getBalance()-200; //加上延时，模拟更加真实 try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); }
setBalance(temp);
System.out.println("取款后："+getBalance());
}
}
//存款
class Save implements Runnable{
private Bank bank;
public Save(Bank bank){
this.bank=bank;
}
@Override
public void run() {
bank.saveAccount();
}
}
//取款
class Draw implements Runnable{
private Bank bank;
public Draw(Bank bank){
this.bank=bank;
}
@Override
public void run() {
bank.drawAccount();
}
}
public class BankTest {
public static void main(String[] args) {
Bank bank=new Bank("Sir li",1000);
Save save=new Save(bank);
Draw draw=new Draw(bank);
Thread thread=new Thread(save);
Thread thread1=new Thread(draw);
thread.start();
thread1.start();
try {
thread.join();
thread1.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(bank);
}
}
运行结果：
存款后：1100
取款后：1100
Bank{account='Sir li', balance=1100}
可以看到程序是：在执行了saveAccount()后，balance=1000+100, 在准备执行drawAccount()时，碰到了延时，没有执行 setBalance(temp)，直接执行输出语句，最后时主线程中的语句，join()保证了线程的执行顺序没有问题，但是跳过了方法中某些语句的执行。
解决办法：
关键字：synchronized 。给方法加锁
运行结果：正常
存款后：1100
取款后：900
Bank{account='Sir li', balance=900}
3.线程间通信
关键字：wait(),死锁，notify(),notifyAll()
举例：生产与消费。 生产n个，消费 n个，来看看程序如何处理
public class Queue {
private int n;
public synchronized int getN() {
System.out.println("消费"+n);
return n;
}
public synchronized void setN(int n) {
System.out.println("生产"+n);
this.n = n;
}
}
class Producer implements Runnable{
private Queue queue;
public Producer(Queue queue){
this.queue=queue;
}
@Override
public void run() {
int i=0;
while (true){
queue.setN(i++);
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
class Consumer implements Runnable{
private Queue queue;
public Consumer(Queue queue){
this.queue=queue;
}
@Override
public void run() {
while (true){
queue.getN();
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
public class ProducerTest {
public static void main(String[] args) {
Queue queue=new Queue();
Producer producer=new Producer(queue);
Consumer consumer=new Consumer(queue);
Thread thread=new Thread(producer);
Thread thread1=new Thread(consumer);
thread.start();
thread1.start();
}
}
运行结果
生产0 消费0 生产1 //生产一次消费了两次，程序还是有问题的 消费1 消费1 生产2 消费2
程序应该满足这样的要求：在没有生产的时候是不能消费的，消费的线程需要”等待“。同样在没有被消费之前，也是不能生产的，生产线程需要的”等待“。
public class Queue {
private int n;
boolean isHave=false;// 增加判断条件
public synchronized int getN() {
if (!isHave){
try {
wait(); //当没有生产的时候，进入阻塞状态
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println("消费"+n);
isHave=false;
return n;
}
public synchronized void setN(int n) {
if(isHave){
try {
wait(); //在没有消费的时候，进行阻塞状态
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println("生产"+n);
this.n = n;
isHave=true;
}
}
运行结果：
生产0 消费0 生产1 消费1 生产2//程序停止输出了，这时候进入了死锁状态，线程之间都在互相等待，需要执行唤醒操作
解决办法：
在getN(),setN()方法中添加：notifyAll();//唤醒线程
结果正常了。。。
4.总结
join():会让当前线程执行完毕，再去执行别的线程。保证了线程的执行顺序。
sychronized: 让被修饰的方法完整的执行。
wait():从功能来看，与判断组合，它也保证了线程的执行顺序。
死锁：程序因为遭到线程都在“等待”状态，而无法运行的情况。