第37节：多线程安全问题

定义用户去银行存钱，每次存100，存3次

class Bank {
 // 总数
 private int sum;
// 定义方法
 public void add(int num){
  // 传入参数
  sum = sum + sum;
 // 加后的值
  System.out.println("sum"+sum);
 }
}

class Demo implements Runnable{
 // 定义银行类对象，创建实例对象
 private Bank  b = new Bank();
// 线程run()
 public void run(){
  for(int x=0; x<3; x++){
   // 将参数放入对象方法中
   b.add(100)
  }
 }
}

// 测试类
class Test{
 public static void main(String[] args){h
  // 创建对象
  Demo d=new Demo();
 // 创建线程对象
  Thread t1 = new Thread(d);
  Thread t2 = new Thread(d);
 // 线程开启
  t1.start();
  t2.start();
}
}

如果出现这个代码，出现了多线程安全问题。共性数据即共享对象中的数据。

class Bank {
 // 总数
 private int sum;
// 创建对象
 private Object obj = new Object();
// 定义方法
 public void add(int num){
  synchronized(obj){
  // 传入参数
  sum = sum + sum;
 // 加后的值
  System.out.println("sum"+sum);
 }
 }
}

安全问题，加了同步可以解决数据安全。

class Tickets implements Runnable{
 private int tickets = 100;
 private Object obj = new Object();
 public void run(){
  whilt(true){
   synchronized(obj){
    if(tickets>0){
     try{
      Thread.sleep(1000);
     }catch(Exception e){
      System.out.println(Thread.currentThread().getName()+tickets);
     }
    }
   }
  }
 }
}

饿汉式

class Single{
 private static final Single s = new Single();
 private Single(){)
 public static Single getInstance(){
  return s;
 }
}

懒汉式

class Single{
 private static Single s = null;
 private Single(){}
 public static Single getInstance(){
  if(s==null){
   s = new Single();
  }
 return s;
 }
}

多线程

在同一时间,做多件事情.

创建线程的方法
继承类Thread并重写run()，run()称为线程体；用这种方法定义的类不能再继承其他类。

class FirstThread extends Thread{
public void run(){
 for(int i=0;i<100;i++){
  System.out.println("FirstThread"+i);
 }
}
}

class Test{
public static void main(Sting args[]){
 FirstThread ft = new FirstThread();
 ft.start();

 for(int i = 0; i<100;i++){
  System.out.println("main"+i):
 }
}
}

接口Runnable的类作为线程的目标对象

class Test implements Runnable{
public void run(){
 for(int i = 0;i<100;i++){
  System.out.println("Runnable"+i);
 }
}
}

class Test{
public static void main(String args[]){
 Test test = new Test();
 Thread t = new Thread(test);
 System.out.println(t.getPriority());
 t.start();
}
}

唤醒线程

线程类

主方法类

线程同步与等待

线程的同步

关键字synchronized

多线程就是调用这个synchronized的方法的，
当线程用了这个方法，那么其他线程想使用这个方法时就得等，直到线程使用完该调用的方法。

同步中的等待

wait()方法：暂时让出cpu；
notifyAll()方法：等待结束。

线程是程序中的执行线程，在Java虚拟机中允许应用程序并发地运行多个执行线程，每个线程独有它自己的一个优先级，高的优先级的执行线程优先于低优先级的线程，每个线程都可以有或者不可以标记的一个守护程序。当一个线程中的运行代码创建一个Thread对象的时候，该线程的初始化优先级就被设定，只有创建线程是守护线程的时候，这个线程才是守护程序。

在Java中的虚拟机启动，通常会有单个非守护线程，一般在代码中有个线程为主线程，main方法。

第36节：Java当中的线程
第35节：Java面向对象中的多线程

这两篇文章讲了什么是进程，什么是线程等一些概念。

进程要执行需要依赖线程，线程是进程中最小的执行单位，一个进程中至少要有一个线程，在线程中串行是单条线程来执行多个任务来说的，任务A到任务B到任务C，只有任务A完成了后才开始到任务B，一条线完成。并行为开启多个线程同时进行任务，同一时刻发生任务A，任务B，任务C。

什么是线程安全

线程出现问题是在多线程的情况之下产生的。出现线程安全问题，如何去解决这个问题呢？用synchronized关键字，用来控制线程同步的，可以让线程在多线程的情况下，不被多个线程同时执行，保证我们数据的安全性。

public synchronized void add(int i){
 ...
}

Lock的引入让锁有了可操作性，它是在Java1.6被引入进来的，Lock可以去手动获取锁和释放锁。

// ReentrantLock是Lock的子类
private Lock lock = new ReentrantLock(); 

private void methodThread(Thread thread){
       // 获取锁对象
       lock.lock(); 
       try {
           System.out.println(thread.getName() + "获得了锁");
       }catch(Exception e){
           e.printStackTrace();
       } finally {
           System.out.println(thread.getName() + "释放了锁");
           // 释放锁对象
           lock.unlock(); 
       }
}

往后余生，努力学习
简书作者：达叔小生
90后帅气小伙，爱编程，爱运营，爱折腾。
简书博客： https://www.jianshu.com/u/c785ece603d1

结语

• 下面我将继续对其他知识 深入讲解 ，有兴趣可以继续关注
• 小礼物走一走 or 点赞