Java并发编程之介绍线程安全基础
- coldplay.xixi转载
- 2021-02-24 10:10:392591浏览
免费学习推荐：java基础教程
线程安全基础
- 1.线程安全问题
- 2.账户取款案例
- 3.同步代码块synchronized
- synchronized的理解
- 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并发编程之介绍线程安全基础的详细内容。更多信息请关注PHP中文网其他相关文章！