java基础语法（三十六）线程和进程（三）——线程安全
关于多线程并发环境下，数据的安全问题.
1.1.为什么这个是重点?
以后在开发中，我们的项目都是运行在服务器当中，
而服务器已经将线程的定义，线程对象的创建，线程
的启动等，都已经实现完了.这些代码我们都不需要
编写.
最重要的是:你要知道，你编写的程序需要放到一个
多线程的环境下运行，你更需要关注的是这些数据
在多线程并发的环境下是否是安全的。(重点: ***)
1.2、什么时候数据在多线程并发的环境下会存在安全问题呢?
同时满足三个条件:
条件1:多线程并发。
条件2:有共享数据。
条件3:共享数据有修改的行为。
1.3.怎么解决线程安全问题呢?
当多线程并发的环境下，有共享数据，并且这个数据还会被修改，此时就存在线程安全问题，怎么解决这个问题?
线程排队执行。(不能并发)。
用排队执行解决线程安全问题.
这种机制被称为:线程同步机制。
线程同步，实际上就是线程不能并发了，线程必须排队执行。
怎么解决线程安全问题呀?
使用“线程同步机制"。
1.4.说到线程同步这块，涉及到这两个专业术语:
异步编程模型:
线程t1和线程t2,各自执行各自的，t1不管t2, t2不管t1,
谁也不需要等谁，这种编程模型叫做:异步编程模型.
其实就是:多线程并发(效率较高。)
同步编程模型:
线程t1和线程t2，在线程t1执行的时候，必须等待t2线程执行
结束，或者说在t2线程执行的时候，必须等待t1线程执行结束，
两个线程之间发生了等待关系，这就是同步编程模型.
效率较低。线程排队执行。
接下来看一个线程安全问题，如下图所示，银行账户取钱可能存在安全问题。
定义一个银行账户类
/*
银行账户
不使用线程同步机制,多线程对同一个账户进行取款,出现线程安全问题。
*/
public class Account {
//账号
private String actno;
//余额
private double balance;
public Account() {
}
public Account(String actno, double balance) {
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){
//取款之前的余额
double before=this.getBalance();
//取款之后的余额
double after=before-money;
//在这里模拟一下网络延迟，一定会出问题
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
//更新余额
this.setBalance(after);
}
}
定义两个线程用于对银行同一个账户进行操作
public class AccountThread extends Thread {
//两个线程必须共享同一个账户对象
private Account act;
//通过构造方法传递过来构造对象
public AccountThread(Account act){
this.act=act;
}
public void run(){
//run方法执行的时候表示取款操作
//假设取款5000
double money=5000;
//取款
act.withdraw(money);
System.out.println(Thread.currentThread().getName()+"对"+act.getActno()+"取款"+money+"成功，余额"+act.getBalance());
}
}
定义一个测试类
public class Test {
public static void main(String[] args) {
//创建账户对象（只创建1个）
Account act=new Account("act-001",10000);
//创建两个线程
Thread t1=new AccountThread(act);
Thread t2=new AccountThread(act);
//设置name
t1.setName("t1");
t2.setName("t2");
//启动线程取款
t1.start();
t2.start();
}
}
对上述存在的不安全问题的解决
使用线程同步机制
package thread.threadsafe2;
/*
银行账户
使用线程同步机制,解决线程安全问题。
*/
public class Account {
//账号
private String actno;
//余额
private double balance;
Object obj=new Object();
public Account() {
}
public Account(String actno, double balance) {
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){
//以下这几行代码必须是线程排队的，不能并发
//一个线程把这里的代码全部执行结束之后,另一个线程才能进来。
/*
线程同步机制的语法是:
synchronized(){
// 线程同步代码块。
}
synchronized后面小括号中传的这个数据是相当关健的。
这个数据必须是多线程共享的数据。才能达到多线程排队。
()中写什么?
那要看想让哪些线程同步。
假设t1、t2、t3、t4、t5 ,有5个线程.
只希望t1、t2、t3排队，t4、t5不需要排队。怎么办?
一定要在()中写一个t1、t2 、t3共享的对象。而这个
对象对于t4、t5来说不是共享的。
这里的共享对象是:账户对象。
账户对象是共享的,那么this就是账户对象吧! ! !
不一定是this,这里只要是多线程共享的那个对象就行。
在java语言中，任何一个对象都有“一把锁”,其实这把锁就是标记。( 只是把它叫做锁。)
100个对象。100把锁。1个对象1把锁。
以下代码的执行原理?
1、假设t1和t2线程并发,开始执行以下代码的时候，肯定有一个先一个后。
2.假设t1先执行了，遇到了synchronized ,这个时候自动找“后面共享对象”的对象锁，
找到之后,并占有这把锁，然后执行同步代码块中的程序，在程序执行过程中一直都是
占有这把锁的。直到同步代码块代码结束,这把锁才会释放。
3.假设t1已经占有这把锁，此时t2也遇到synchronized关键字，也会去占有后面
共享对象的这把锁,结果这把锁被t1占有, t2只能在同步代码块外面等待t1的结束,
直到1把同步代码块执行结束了, t1会归还这把锁,此的t2终于等到这把锁,然后
t2占有这把锁之后,进入同步代码块执行程序。
这样就达到了线程排队执行。
这里需要注意的是:这个共享对象一定要选好了。这个共享对象一定是需要排队
执行的这些线程对象所共享的。
*/
Object obj2=new Object();
synchronized (this){
//synchronized (obj){
//synchronized (obj2){//这样写就不安全了。因为obj2不是共享对象
//synchronized ("abc"){//字符串在常量池当中，只有一个。是所有的线程都会同步
//取款之前的余额
double before=this.getBalance();
//取款之后的余额
double after=before-money;
//在这里模拟一下网络延迟，一定会出问题
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
//更新余额
this.setBalance(after);
}
}
}
public class AccountThread extends Thread {
//两个线程必须共享同一个账户对象
private Account act;
//通过构造方法传递过来构造对象
public AccountThread(Account act){
this.act=act;
}
public void run(){
//run方法执行的时候表示取款操作
//假设取款5000
double money=5000;
//取款
act.withdraw(money);
System.out.println(Thread.currentThread().getName()+"对"+act.getActno()+"取款"+money+"成功，余额"+act.getBalance());
}
}
public class Test {
public static void main(String[] args) {
//创建账户对象（只创建1个）
Account act=new Account("act-001",10000);
//创建两个线程
Thread t1=new AccountThread(act);
Thread t2=new AccountThread(act);
//设置name
t1.setName("t1");
t2.setName("t2");
//启动线程取款
t1.start();
t2.start();
}
}
在实例方法上可以使用synchronized吗?可以的。
synchronized出现在实例方法上，一定锁的是this。
public class Account {
//账号
private String actno;
//余额
private double balance;
public Account() {
}
public Account(String actno, double balance) {
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;
}
//取款的方法
/*
在实例方法上可以使用synchronized吗?可以的。
synchronized出现在实例方法上，一定锁的是this。
没得挑。只能是this。 不能是其他的对象了。
所以这种方式不灵活。
另外还有一个缺点: synchronized出现在实例方法上，
表示整个方法体都需要同步，可能会无故扩大同步的
范围，导致程序的执行效率降低。所以这种方式不常用。
synchronized使用在实例方法上有什么优点?
代码写的少了。节俭了。
如果共享的对象就是this ,并且需要同步的代码块是整个方法体,
建议使用这种方式。
*/
public synchronized void withdraw(double money){
double before=this.getBalance();
double after=before-money;
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
this.setBalance(after);
}
}
public class AccountThread extends Thread {
//两个线程必须共享同一个账户对象
private Account act;
//通过构造方法传递过来构造对象
public AccountThread(Account act){
this.act=act;
}
public void run(){
//run方法执行的时候表示取款操作
//假设取款5000
double money=5000;
//取款
act.withdraw(money);
System.out.println(Thread.currentThread().getName()+"对"+act.getActno()+"取款"+money+"成功，余额"+act.getBalance());
}
}
public class Test {
public static void main(String[] args) {
//创建账户对象（只创建1个）
Account act=new Account("act-001",10000);
//创建两个线程
Thread t1=new AccountThread(act);
Thread t2=new AccountThread(act);
//设置name
t1.setName("t1");
t2.setName("t2");
//启动线程取款
t1.start();
t2.start();
}
}
Java中有有三大变量?
实例变量:在堆中.
静态变量:在方法区.
局部变量:在栈中。
以上三大变量中:
局部变量永远都不会存在线程安全问题.
因为局部变量不共享。(一个线程一个栈。)
局部变量在栈中。所以局部变量永远都不会共享.
实例变量在堆中，堆只有1个。
静态变量在方法区中，方法区只有1个.
堆和方法区都是多线程共享的，所以可能存在线程安全问题。
局部变量+常量:不会有线程安全问题。
成员变量:可能会有线程安全问题。
如果使用局部变量的话:
建议使用: StringBuilder.
因为局部变量不存在线程安全问题。选择StringBuilder.
StringBuffer效率比较低。
ArrayList是非线程安全的。
Vector是线程安全的.
HashMap Hashset是非线程安全的.
Hashtable是线程安全的。
以下代码： doOther方法执行的时候需要等待doSome方法的结束吗?
不需要，因为doOther()方法没有synchronized
public class Exam01 {
public static void main(String[] args) throws InterruptedException {
MyClass mc=new MyClass();
Thread t1=new MyThread(mc);
Thread t2=new MyThread(mc);
t1.setName("t1");
t2.setName("t2");
t1.start();
Thread.sleep(1000);//这个睡眠的作用是：为了保证t1先执行
t2.start();
}
}
class MyThread extends Thread{
private MyClass mc;
public MyThread(MyClass mc){
this.mc=mc;
}
public void run(){
if (Thread.currentThread().getName().equals("t1")){
mc.doSome();
}
if(Thread.currentThread().getName().equals("t2")){
mc.doOther();
}
}
}
class MyClass{
//synchronized出现在实例方法上，表示锁this
public synchronized void doSome(){
System.out.println("doSome begin");
try {
Thread.sleep(1000*10);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("doSome over");
}
public void doOther(){
System.out.println("doOther begin");
System.out.println("doOther over");
}
}
以下代码：
doOther方法执行的时候需要等待doSome方法的结束吗?
需要 ，doSome()释放了锁，doOther()才可以拿到锁。
public class Exam01 {
public static void main(String[] args) throws InterruptedException {
MyClass mc=new MyClass();
Thread t1=new MyThread(mc);
Thread t2=new MyThread(mc);
t1.setName("t1");
t2.setName("t2");
t1.start();
Thread.sleep(1000);//这个睡眠的作用是：为了保证t1先执行
t2.start();
}
}
class MyThread extends Thread{
private MyClass mc;
public MyThread(MyClass mc){
this.mc=mc;
}
public void run(){
if (Thread.currentThread().getName().equals("t1")){
mc.doSome();
}
if(Thread.currentThread().getName().equals("t2")){
mc.doOther();
}
}
}
class MyClass{
//synchronized出现在实例方法上，表示锁this
public synchronized void doSome(){
System.out.println("doSome begin");
try {
Thread.sleep(1000*10);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("doSome over");
}
public synchronized void doOther(){
System.out.println("doOther begin");
System.out.println("doOther over");
}
}
以下代码：
doOther方法执行的时候需要等待doSome方法的结束吗?
不需要 因为MyClass有两个对象，两把锁
public class Exam01 {
public static void main(String[] args) throws InterruptedException {
MyClass mc1=new MyClass();
MyClass mc2=new MyClass();
Thread t1=new MyThread(mc1);
Thread t2=new MyThread(mc2);
t1.setName("t1");
t2.setName("t2");
t1.start();
Thread.sleep(1000);//这个睡眠的作用是：为了保证t1先执行
t2.start();
}
}
class MyThread extends Thread{
private MyClass mc;
public MyThread(MyClass mc){
this.mc=mc;
}
public void run(){
if (Thread.currentThread().getName().equals("t1")){
mc.doSome();
}
if(Thread.currentThread().getName().equals("t2")){
mc.doOther();
}
}
}
class MyClass{
//synchronized出现在实例方法上，表示锁this
public synchronized void doSome(){
System.out.println("doSome begin");
try {
Thread.sleep(1000*10);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("doSome over");
}
public synchronized void doOther(){
System.out.println("doOther begin");
System.out.println("doOther over");
}
}
以下代码的执行：
doOther方法执行的时候需要等待doSome方法的结束吗?
需要，因为静态方法是类锁，不管创建了几个对象，类锁只有1把
public class Exam01 {
public static void main(String[] args) throws InterruptedException {
MyClass mc1=new MyClass();
MyClass mc2=new MyClass();
Thread t1=new MyThread(mc1);
Thread t2=new MyThread(mc2);
t1.setName("t1");
t2.setName("t2");
t1.start();
Thread.sleep(1000);//这个睡眠的作用是：为了保证t1先执行
t2.start();
}
}
class MyThread extends Thread{
private MyClass mc;
public MyThread(MyClass mc){
this.mc=mc;
}
public void run(){
if (Thread.currentThread().getName().equals("t1")){
mc.doSome();
}
if(Thread.currentThread().getName().equals("t2")){
mc.doOther();
}
}
}
class MyClass{
//synchronized出现在静态方法上是找类锁
public synchronized static void doSome(){
System.out.println("doSome begin");
try {
Thread.sleep(1000*10);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("doSome over");
}
public synchronized static void doOther(){
System.out.println("doOther begin");
System.out.println("doOther over");
}
}
总结:
synchronized有三种写法:
第一种:同步代码块
灵活
synchronized (线程共享对象) {
同步代码块;
}
第二种:在实例方法上使用synchronized
表示共享对象一定是this
并且同步代码块是整个方法体.
第三种:在静态方法上使用synchronized
表示找类锁。
类锁永远只有1把。
就算创建了100个对象，那类锁也只有一把。
对象锁: 1个对象1把锁，100个对象100把锁。
类锁: 100个对象，也可能只是1把类锁.
以后开发中应该怎么解决线程安全问题?
是一上来就选择线程同步吗? synchronized
不是，synchronized会让程序的执行效率降低，用户体验不好.
系统的用户吞吐量降低。用户体验差。在不得已的情况下再选择
线程同步机制.
第一种方案:尽量使用局部变量代替"实例变量和静态变量"。
第二种方案:如果必须是实例变量，那么可以考虑创建多个对象，这样
实例变量的内存就不共享了(一个线程对应1个对象， 100个线程对应100个对象,
对象不共享，就没有数据安全问题了. )
第三种方案:如果不能使用局部变量，对象也不能创建多个，这个时候
就只能选择synchronized了.线程同步机制.