Java并发编程之介绍线程安全基础

Java|Java基础 线程安全基础1.线程安全问题2.账户取款案例3.同步代码块synchronizedsynchronized的理解java中有三大变量的线程安全问题在实例方法上使用synchronized总结面试题4.死锁5.开发中应该怎么解决线程安全问题6.守护线程7.定时器8.实现线程的第三种方式：实现Callable接口9.Object类中的wait和notify方法10.生产者和消费者1.线程安全问题

2.1、为什么这个是重点？
  以后在开发中，我们的项目都是运行在服务器当中，而服务器已经将线程的定义，线程对象的创建，线程的启动等，都已经实现完了。这些代码我们都不需要编写。
  最重要的是：你要知道，你编写的程序需要放到一个多线程的环境下运行，你更需要关注的是这些数据在多线程并发的环境下是否是安全的。（重点：*****）
2.2、什么时候数据在多线程并发的环境下会存在安全问题呢？

  三个条件：
  条件1：多线程并发。
  条件2：有共享数据。
  条件3：共享数据有修改的行为。
  满足以上3个条件之后，就会存在线程安全问题。
2.3、怎么解决线程安全问题呢？
当多线程并发的环境下，有共享数据，并且这个数据还会被修改，此时就存在线程安全问题，怎么解决这个问题？
  线程排队执行。（不能并发）。
  用排队执行解决线程安全问题。
  这种机制被称为：线程同步机制。
  专业术语叫做：线程同步，实际上就是线程不能并发了，线程必须排队执行。
  怎么解决线程安全问题呀？
  使用“线程同步机制”。
  线程同步就是线程排队了，线程排队了就会牺牲一部分效率，没办法，数据安全第一位，只有数据安全了，我们才可以谈效率。数据不安全，没有效率的事儿。
2.4、说到线程同步这块，涉及到这两个专业术语：
异步编程模型：
  线程t1和线程t2，各自执行各自的，t1不管t2，t2不管t1，
  谁也不需要等谁，这种编程模型叫做：异步编程模型。
  其实就是：多线程并发（效率较高。）

同步编程模型：
  线程t1和线程t2，在线程t1执行的时候，必须等待t2线程执行结束，或者说在t2线程执行的时候，必须等待t1线程执行结束，两个线程之间发生了等待关系，这就是同步编程模型。效率较低。线程排队执行。

异步就是并发。同步就是排队。

2.账户取款案例

Account类

package ThreadSafe;public class Account {	//账号	private String actno;	//余额	private double balance;		public Account(String actno, double balance) {		super();		this.actno = actno;		this.balance = balance;	}	public String getActno() {		return actno;	}	public void setActno(String actno) {		this.actno = actno;	}	public double getBalance() {		return balance;	}	public void setBalance(double balance) {		this.balance = balance;	}	//取款的方法	public void withdraw(double money){		//t1和t2并发执行这个方法（t1和t2是两个栈 ，两个栈操作堆中同一个对象）		//取款之前的余额		double before=this.getBalance();		//取款之后的余额		double after=before-money;		//模拟一下网络延迟，会出现问题		try {			Thread.sleep(1000);		} catch (InterruptedException e) {			// TODO Auto-generated catch block			e.printStackTrace();		}		//更新余额		//思考：t1执行到这里了，但还没有来得及执行这行代码，t2线程进来withdraw方法了，此时一定出问题		this.setBalance(after);	}}AccountThread类public class AccountThread extends Thread{	//两个线程必须共享一个账户对象	private Account act;	//通过构造方法传递过来账户对象	public AccountThread(Account act) {		this.act = act;	}	@Override	public void run() {		//假设取款5000		double money=5000;		//多线程执行这个方法		act.withdraw(money);		System.out.println(Thread.currentThread().getName()+"账户"+act.getActno()+"取款成功"+act.getBalance());	}}

Test类

public class Test {	public static void main(String[] args) {		//创建账户对象		Account act=new Account("act-001",10000);		//创建两个线程		Thread t1=new AccountThread(act);		Thread t2=new AccountThread(act);				t1.setName("t1");		t2.setName("t2");		//启动两个线程执行		t1.start();		t2.start();	}}

3.同步代码块synchronized

synchronized的理解

//以下这几行代码必须是线程排队的，不能并发
//一个线程把这里的代码全部执行结束后，另一个线程才能进来
/*
线程同步机制的语法是
synchronized(){
//线程同步代码块。
}
synchronized后面小括号中传的这个数据是相当关键的，
这个数据必须是多线程共享的数据，才能达到多线程排队。
()中写什么？
那要看你想让哪些线程同步
假设t1、t2、t3、t4、t5有5个线程
你只希望t1 t2 t3排队，t4 t5不需要排队，怎么办
你一定要在()中写一个t1 t2 t3共享的对象，而这个对象对于t4 t5来说不是共享的
这里的共享对象是账户对象
账户对象是共享的，this是账户对象
有时不一定是this,这里只要是多线程共享的那个对象就行

		synchronized(this){			double before=this.getBalance();			double after=before-money;			try {				Thread.sleep(1000);			} catch (InterruptedException e) {				// TODO Auto-generated catch block				e.printStackTrace();			}			this.setBalance(after);		}

在java语言中，任何对象都有一把锁，其实这把锁就是一个标记，（只是把它叫做锁）
100个对象，100个锁，1个对象1把锁。
以上代码的执行原理是什么呢？
1.假设t1和t2线程并发，开始执行以上代码的时候，肯定有一个先一个后，
2.假设t1先执行了，遇到了synchronized，这个时候自动找后面共享对象的对象锁，找到之后，并占有这把锁，然后执行同步代码块中的程序，在程序执行过程中一直都占有这把锁，直到同步代码块执行结束，这把锁才会释放。
3.假设t1已经占有这把锁，此时t2也遇到synchronized关键字，也会去占有后面共享对象的这把锁，结果这把锁被t1占有，t2只能在同步代码块外边等待t1的结束，直到t1把同步代码块执行结束了，t1会归还这把锁，此时t2终于等到这把锁，然后t2占有这把锁之后，进入同步代码块执行程序。
这样就达到了线程排队执行
这里需要注意的是：这个共享对象一定要选好了，这个共享对象一定是你需要排队执行的这些线程对象所共享的。
//对象
Object obj=new Object(); //实例变量（Account对象是多线程共享的，Account对象中的实例变量obj也是共享的）
synchronized(obj){}

括号里边只要是共享对象就行。
Object obj2=new Object(); //局部变量
synchronized(obj2){}
这样写就不安全了，因为obj2是局部变量，不是共享对象。
synchronized(“abc”){}
这样写时可以的。存在字符串常量池中
写”abc”的话所有线程都会同步
而如果是写synchronized(this){}的话，我们创建了一个新的对象act2可不用共享对象。
所以最好是写synchronized(this){}，比如你要取款，要让其他取别的账户的人也要等吗？不应该，只有同时对你这1个账户取款的时候，需要等待，别人取钱的时候，需要从其他账户中取钱，就不需要等待。

java中有三大变量的线程安全问题

实例变量，在堆中
静态变量，在方法区
局部变量，在栈中
以上三大变量
局部变量永远不会存在线程安全问题
因为局部变量不共享（一个线程一个栈）
局部变量在栈中，所以局部变量永远都不会共享
实例变量在堆中，堆只有1个。
静态变量在方法区中，方法区只有1个。
堆和方法区都是多线程共享的，所以可能存在线程安全问题。

局部变量+常量：不会有线程安全问题。
成员变量：可能会有线程安全问题。

同步代码块越小，效率越高。

//多线程执行这个方法//synchronized(this)//这里的this是AccountThread对象，这个对象不共享。synchronized(act){			act.withdraw(money);			System.out.println(Thread.currentThread().getName()+"账户"+act.getActno()+"取款成功，余额："+act.getBalance());}

在实例方法上使用synchronized

在实例方法上可以使用synchronized吗？可以的。
synchronized出现在实例方法上，一定锁的是this
没得挑，只能是this,不能是其他的对象了
所以这种方式不灵活。
另外还有一个缺点：synchronized出现在实例方法上，表示整个方法体都需要同步
可能会扩大同步的范围，导致程序的执行效率降低。所以这种方式不常用。
synchronized使用在实例方法上有什么优点?
代码写的少了，节俭了。
如果共享的对象是this，并且需要同步的代码是整个方法体，建议使用这种方式。
StringBuffer就是在每个方法上加了synchronized关键字

使用局部变量的话，最好使用StringBuilder
因为局部变量不存在线程安全问题，选择StringBuilder，StringBuffer效率比较低。
ArrayList是非线程安全的。
Vector是线程安全的。
HashMap HashSet是非线程安全的。
Hashtable是线程安全的。

总结

synchronized有三种写法：

  第一种：同步代码块
    灵活
      synchronized(线程共享对象){
        同步代码块;
      }
  第二种：在实例方法上使用synchronized
      表示共享对象一定是this
      并且同步代码块是整个方法体。
  第三种：在静态方法上使用synchronized
      表示找类锁。
      类锁永远只有1把。
      就算创建了100个对象，那类锁也只有一把。

对象锁：1个对象1把锁，100个对象100把锁。
类锁：100个对象，也可能只是1把类锁。

面试题

//面试题：doother方法的执行需不需要等待dosome方法的结束。
//不需要，因为doother方法没有synchronized

public class exam01 {	public static void main(String[] args) {		MyClass mc=new MyClass();		Thread t1=new MyThread(mc);		Thread t2=new MyThread(mc);		t1.setName("t1");		t2.setName("t2");		t1.start();		try {			Thread.sleep(1000);		//这个睡眠的作用是：为了保证t1线程先执行		} catch (InterruptedException e) {			// TODO Auto-generated catch block			e.printStackTrace();		}		t2.start();	}}class MyThread extends Thread{	private MyClass mc;	public MyThread(MyClass mc) {		super();		this.mc = mc;	}	public void run(){		if(Thread.currentThread().getName().equals("t1")){			mc.dosome();		}		if(Thread.currentThread().getName().equals("t2")){			mc.doOther();		}	}	}class MyClass{	public synchronized void dosome(){		System.out.println("doSome begin");		try {			Thread.sleep(1000);		} catch (InterruptedException e) {			// TODO Auto-generated catch block			e.printStackTrace();		}		System.out.println("doSome end");	}	public void doOther(){		System.out.println("doOther begin");		System.out.println("doOther end");	}}

当在doother上面加了synchronized呢
//面试题：doother方法的执行需不需要等待dosome方法的结束。
//需要，因为doother方法没有synchronized

	public synchronized void doOther(){		System.out.println("doOther begin");		System.out.println("doOther end");	}

//面试题：doother方法的执行需不需要等待dosome方法的结束。
//不用排队，谁也不用管谁

MyClass mc1=new MyClass();MyClass mc2=new MyClass();Thread t1=new MyThread(mc1);Thread t2=new MyThread(mc2);

//面试题：doother方法的执行需不需要等待dosome方法的结束。
//需要，因为静态方法是类锁，类锁不管创建了几个对象，类锁只有一把

MyClass mc1=new MyClass();MyClass mc2=new MyClass();Thread t1=new MyThread(mc1);Thread t2=new MyThread(mc2);public synchronized static void dosome(){		System.out.println("doSome begin");		try {			Thread.sleep(1000);		} catch (InterruptedException e) {			// TODO Auto-generated catch block			e.printStackTrace();		}		System.out.println("doSome end");	}	public synchronized static void doOther(){		System.out.println("doOther begin");		System.out.println("doOther end");	}

这种锁叫排他锁:

4.死锁

synchronized在开发中最好不要嵌套使用，一不小心就可能导致死锁。
死锁代码要会写。
一般面试官要求你会写
只有会写的，才会在以后的开发中注意这个事儿
因为死锁很难调试。

public class DeadLock {	public static void main(String[] args) {		Object o1=new Object();		Object o2=new Object();		//t1线程和t2线程共享o1,o2		Thread t1=new MyThread1(o1,o2);		Thread t2=new MyThread2(o1,o2);		t1.start();		t2.start();	}}class MyThread1 extends Thread{	Object o1;	Object o2;	public MyThread1(Object o1,Object o2){		this.o1=o1;		this.o2=o2;	}	@Override	public void run() {		synchronized (o1) {			try {				Thread.sleep(1000);			} catch (InterruptedException e) {				// TODO Auto-generated catch block				e.printStackTrace();			}			synchronized (o2) {							}		}	}}class MyThread2 extends Thread{	Object o1;	Object o2;	public MyThread2(Object o1,Object o2){		this.o1=o1;		this.o2=o2;	}	@Override	public void run() {		synchronized (o2) {			try {				Thread.sleep(1000);			} catch (InterruptedException e) {				// TODO Auto-generated catch block				e.printStackTrace();			}			synchronized (o1) {							}		}	}}

5.开发中应该怎么解决线程安全问题

聊一聊，我们以后开发中应该怎么解决线程安全问题？
  是一上来就选择线程同步吗？synchronized
  不是，synchronized会让程序的执行效率降低，用户体验不好。
  系统的用户吞吐量降低。用户体验差。在不得已的情况下再选择
  线程同步机制。
  第一种方案：尽量使用局部变量代替“实例变量和静态变量”。
  第二种方案：如果必须是实例变量，那么可以考虑创建多个对象，这样实例变量的内存就不共享了。（一个线程对应1个对象，100个线程对应100个对象，对象不共享，就没有数据安全问题了。）
  第三种方案：如果不能使用局部变量，对象也不能创建多个，这个时候就只能选择synchronized了。线程同步机制。
线程这块还有那些内容呢？列举一下
7.1、守护线程
7.2、定时器
7.3、实现线程的第三种方式：FutureTask方式，实现Callable接口。（JDK8新特性。）
7.4、关于Object类中的wait和notify方法。（生产者和消费者模式！）

6.守护线程

守护线程
java语言中线程分为两大类：
  一类是：用户线程
  一类是：守护线程（后台线程）
其中具有代表性的就是：垃圾回收线程（守护线程）。
  守护线程的特点：
  一般守护线程是一个死循环，所有的用户线程只要结束，
  守护线程自动结束。
  注意：主线程main方法是一个用户线程。
  守护线程用在什么地方呢？
  每天00:00的时候系统数据自动备份。
  这个需要使用到定时器，并且我们可以将定时器设置为守护线程。
  一直在那里看着，没到00:00的时候就备份一次。所有的用户线程如果结束了，守护线程自动退出，没有必要进行数据备份了。

package testThread;/*实现守护线程 * */	public class ThreadTest13 {	public static void main(String[] args) {		// TODO Auto-generated method stub		Thread t=new BakDataThread();		t.setName("备份数据的线程");		//启动之前，将线程设置为守护线程		t.setDaemon(true);		t.start();		//主线程：主线程是用户线程		for(int i=0;i"+i);			try {				Thread.sleep(1000);			} catch (Exception e) {				// TODO: handle exception			}		}	}}class BakDataThread extends Thread{	@Override	public void run() {		int i=0;		//即使是死循环，但由于该线程是守护者，当用户线程结束，守护线程自动终止		while(true){			System.out.println(Thread.currentThread().getName()+"---->"+(++i));			try {				Thread.sleep(1000);			} catch (Exception e) {				// TODO: handle exception			}					}	}}

7.定时器

定时器的作用：
  间隔特定的时间，执行特定的程序。
  每周要进行银行账户的总账操作。
  每天要进行数据的备份操作。
  在实际的开发中，每隔多久执行一段特定的程序，这种需求是很常见的，
那么在java中其实可以采用多种方式实现：
  可以使用sleep方法，睡眠，设置睡眠时间，没到这个时间点醒来，执行任务。这种方式是最原始的定时器。（比较low）
  在java的类库中已经写好了一个定时器：java.util.Timer，可以直接拿来用。不过，这种方式在目前的开发中也很少用，因为现在有很多高级框架都是支持定时任务的。

  在实际的开发中，目前使用较多的是Spring框架中提供的SpringTask框架，这个框架只要进行简单的配置，就可以完成定时器的任务。

8.实现线程的第三种方式：实现Callable接口

实现线程的第三种方式：实现Callable接口。（JDK8新特性。）
这种方式实现的线程可以获取线程的返回值。
之前讲解的那两种方式是无法获取线程返回值的，因为run方法返回void。
思考：
系统委派一个线程去执行一个任务，该线程执行完任务之后，可能会有一个执行结果，我们怎么能拿到这个执行结果呢？
使用第三种方式：实现Callable接口方式。

public class ThreadTest14 {	public static void main(String[] args) throws Exception, ExecutionException {		//第一步：创建一个未来任务类对象		//参数非常重要，需要给一个callable接口的实现类对象		FutureTask task=new FutureTask(new Callable(){			@Override			//call方法相当于是run方法，只不过这个有返回值，线程执行一个任务，执行之后可能会有一个执行结果。			public Object call() throws Exception {				System.out.println("call method begin");				Thread.sleep(1000);				System.out.println("call method begin");				int a=100;				int b=200;				return a+b;			//自动装箱			}				});		//创建线程对象		Thread t=new Thread(task);				//启动线程		t.start();				//这里是main方法，这是在主线程中		//在线程中，怎么获取t线程的执行结果		//get方法的执行会导致当前线程阻塞		Object obj=task.get();		System.out.println("线程执行结果"+obj);		//main方法这里的程序要想执行必须等待get()方法的结束		//而get方法可能需要很久。因为get()方法是为了拿另一个线程的执行结果。		//另一个线程的执行是需要时间的		System.out.println("hello,world");	}}

这种方式的优点：可以获取到线程的执行结果
这种方式的缺点：效率比较低，在获取t线程执行结果的时候，当前线程受阻塞，效率较低。

9.Object类中的wait和notify方法

（生产者和消费者模式！）
  第一：wait和notify方法不是线程对象的方法，是java中任何一个java对象都有的方法，因为这两个方式是Object类中自带的。
  wait方法和notify方法不是通过线程对象调用，
  不是这样的：t.wait()，也不是这样的：t.notify()…不对。
  第二：wait()方法作用？
    Object o = new Object();
    o.wait();
  表示：
  让正在o对象上活动的线程进入等待状态，无期限等待，直到被唤醒为止。
  o.wait();方法的调用，会让“当前线程（正在o对象上活动的线程）”进入等待状态。
  第三：notify()方法作用？
    Object o = new Object();
    o.notify();
  表示：
  唤醒正在o对象上等待的线程。
  还有一个notifyAll()方法：
  这个方法是唤醒o对象上处于等待的所有线程。

10.生产者和消费者

1.使用wait方法和notify方法实现生产者和消费者模式
2.什么是生产者和消费者模式？
生产线程负责生产，消费线程负责消费
生产线程和消费线程要达到均衡
这是一种特殊的业务需求，在这种特殊的情况下需要使用wait方法和notify方法
3.wait和notify方法不是线程对象的方法，是普通java对象都有的方法
4.wait方法和notify方法是建立在线程同步的基础之上。因为多线程要同时操作一个仓库，有线程安全问题
5.wait方法作用：o.wait()让正在o对象上活动的线程t进入等待状态，并且释放掉t线程之前占有的o对象的锁
6.notify方法的作用：o.notify()让正在o对象上等待的线程唤醒，只是5通知，不会释放o对象上之前占有的锁
7.模拟这样一个需求：
仓库我们采用list集合
list集合中假设只能存储1个元素
1个元素就表示仓库满了
如果list集合中的元素个数是0，就表示仓库空了。
保证list集合中永远都是最多存储1个元素
必须做到这种效果，生产1个消费1个。

public class ThreadTest15 {	public static void main(String[] args) {		//创建一个仓库独享，共享的		List list=new ArrayList();		//创建两个线程对象		//生产者线程		Thread t1=new Thread(new Producer(list));		//消费者线程		Thread t2=new Thread(new Consumer(list));		t1.setName("生产者线程");		t2.setName("消费者线程");		t1.start();		t2.start();	}}//生产线程class Producer implements Runnable{	//仓库	private List list;	public Producer(List list) {		this.list = list;	}	public void run() {		//一直生产		while(true){			//给仓库对象list加锁			synchronized (list) {				if(list.size()>0){	//大于0说明仓库中已经有1个元素了					//当前线程进入等待状态，并且释放list集合的锁					try {						list.wait();					} catch (InterruptedException e) {						// TODO Auto-generated catch block						e.printStackTrace();					}				}				//程序能够执行到这里说明仓库是空的，可以生产				Object obj =new Object();				list.add(obj);				System.out.println(Thread.currentThread().getName()+"---->"+obj);				//唤醒消费者进行消费				list.notifyAll();			}					}	}}//消费线程class Consumer implements Runnable{	//仓库	private List list;	public Consumer(List list) {		this.list = list;	}	public void run() {		//一直消费		while(true){			//给仓库对象list加锁			synchronized (list) {				if(list.size()==0){	//仓里已经空了					try {						//仓库已经空了						//消费者线程等待，并释放掉list集合锁						list.wait();					} catch (InterruptedException e) {						// TODO Auto-generated catch block						e.printStackTrace();					}				}			}			Object obj=list.remove(0);			System.out.println(Thread.currentThread().getName()+"---->"+obj);			//唤醒生产者生产			list.notifyAll();		}	}}