免费学习推荐：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<10;i++){ system.out.println(thread.currentthread().getname()+"---->+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(); } }}
相关学习推荐：java基础
以上就是java并发编程之介绍线程安全基础的详细内容。