java学习——多线程

本文内容来源于  历经5年锤练--史上最适合初学者入门的Java基础视频

 

线程：就是进程中一个负责程序执行的控制单元(执行路径)

每一个线程都有自己运行的内容。这个内容可以称为线程要执行的任务。

多线程好处：解决了多部分同时运行的问题。

多线程的弊端：线程太多回到效率的降低。

 

JVM启动时就启动了多个线程，至少有两个线程可以分析的出来。

1，执行main函数的线程，
该线程的任务代码都定义在main函数中。

2，负责垃圾回收的线程。

多线程状态图：

如何创建一个线程呢？

创建线程方式一：继承Thread类。

步骤：
1，定义一个类继承Thread类。
2，覆盖Thread类中的run方法。
3，直接创建Thread的子类对象创建线程。
4，调用start方法开启线程并调用线程的任务run方法执行。

class Demo extends Thread{
　　......
　　public void run(){
　　　　......
　　}
}
class ThreadDemo2 {
　　public static void main(String[] args) {
　　 　  Demo d1 = new Demo();
　　　　d1.start();//开启线程，调用run方法。
}

 

线程创建方式二：实现Runnable接口(比较常用)

步骤：
1，定义类实现Runnable接口。
2，覆盖接口中的run方法，将线程的任务代码封装到run方法中。
3，通过Thread类创建线程对象，并将Runnable接口的子类对象作为Thread类的构造函数的参数进行传递。
4，调用线程对象的start方法开启线程。

实现Runnable接口的好处：
1，将线程的任务从线程的子类中分离出来，进行了单独的封装。
按照面向对象的思想将任务的封装成对象。
2，避免了java单继承的局限性。

class Demo implements Runnable{
    public void run(){
        ...
    }
}
class  ThreadDemo{
    public static void main(String[] args) {    
        Demo d = new Demo();
        Thread t1 = new Thread(d);
        Thread t2 = new Thread(d);
        t1.start();
        t2.start();
    }
}

小例子：卖票

线程安全问题产生的原因：

1，多个线程在操作共享的数据。
2，操作共享数据的线程代码有多条。

当一个线程在执行操作共享数据的多条代码过程中，其他线程参与了运算。
就会导致线程安全问题的产生。

解决思路；
就是将多条操作共享数据的线程代码封装起来，当有线程在执行这些代码的时候，
其他线程时不可以参与运算的，必须要当前线程把这些代码都执行完毕后，其他线程才可以参与运算。

在java中，用同步代码块就可以解决这个问题。

同步代码块的格式：
synchronized(对象)
{
　　需要被同步的代码 ；
}

同步的好处：解决了线程的安全问题。

同步的弊端：相对降低了效率，因为同步外的线程的都会判断同步锁。

同步的前提：同步中必须有多个线程并使用同一个锁。

class Ticket implements Runnable{
    private  int num = 100;

    Object obj = new Object();
    public void run(){
        while(true){
            synchronized(obj){　　//锁是任意的，可以使用this，即 synchronized(this)
                if(num>0){
                    try{Thread.sleep(10);}catch (InterruptedException e){}  //睡一下便于发现是否有安全隐患                  
　　　　　　　　　　　 System.out.println(Thread.currentThread().getName()+".....sale...."+num--);                }
            }
        }
    }
}
class  TicketDemo{
    public static void main(String[] args) {

        Ticket t = new Ticket();//创建一个线程任务对象。

        Thread t1 = new Thread(t);
        Thread t2 = new Thread(t);
        Thread t3 = new Thread(t);
        Thread t4 = new Thread(t);

        t1.start();
        t2.start();
        t3.start();
        t4.start();
    }
}

 小例子2：储户，两个，每个都到银行（同一个银行）存钱每次存100，，共存三次。

 涉及：同步函数

class Bank{
    private int sum;
    public synchronized void add(int num)//同步函数：同步的第二种表现形式，锁是this
        {
            sum = sum + num;
            try{Thread.sleep(10);}catch(InterruptedException e){}
            System.out.println("sum="+sum);
    }
}
class Cus implements Runnable{
    private Bank b = new Bank();
    public void run(){
        for(int x=0; x<3; x++){
            b.add(100);
        }
    }
}
class BankDemo {
    public static void main(String[] args) {
        Cus c = new Cus();
        Thread t1 = new Thread(c);
        Thread t2 = new Thread(c);
        t1.start();
        t2.start();
    }
}        

同步函数锁：

同步函数的使用的锁是this；

同步函数和同步代码块的区别：同步函数的锁是固定的this, 同步代码块的锁是任意的对象。

建议使用同步代码块。

静态的同步函数使用的锁是 该函数所属字节码文件对象 
可以用 getClass方法获取，也可以用当前 类名.class 表示。

 

 

复习：单例设计模式 

设计模式：对问题行之有效的解决方式。其实它是一种思想。

1,单例设计模式。
解决的问题：就是可以保证一个类在内存中的对象唯一性。

必须对于多个程序使用同一个配置信息对象时，就需要保证该对象的唯一性。

如何保证对象唯一性呢？
1，不允许其他程序用new创建该类对象。
2，在该类创建一个本类实例。
3，对外提供一个方法让其他程序可以获取该对象。

步骤：
1，私有化该类构造函数。
2，通过new在本类中创建一个本类对象。
3，定义一个公有的方法，将创建的对象返回。

//饿汉式（开发常用）

class Single//类一加载，对象就已经存在了。
{
　　private static Single s = new Single();
　　private Single(){}
　　public static Single getInstance()
　　{return s;}
}

//懒汉式（面试常用）有安全问题

class Single2//类加载进来，没有对象，只有调用了getInstance方法时，才会创建对象。延迟加载形式。 
{  private static Single2 s = null;
　　private Single2(){}
　　public static Single2 getInstance(){  
　　　　if(s==null)　　　　s = new Single2();
　　　　return s;}
}

多线程下的单例模式：

饿汉式没有安全问题，对懒汉式进行修改

加入同步为了解决多线程安全问题。

加入双重判断是为了解决效率问题。

class Single{
　　private static Single s = null;
　　private Single(){}
　　public static Single getInstance(){
　　　　if(s==null){//当s不为null时，则不进行锁的判断，直接返回s
　　　　　　synchronized(Single.class){
　　　　　　　　if(s==null)
　　　　　　　　//    -->0 -->1
　　　　　　　　s = new Single();
　　　　　　}
　　　　}
　　return s;
　　}
}

死锁: 常见情景之一：同步的嵌套。

 

死锁同步嵌套Demo

 

 

线程间通讯：
多个线程在处理同一资源，但是任务却不同。

 

 线程间通讯：等待唤醒机制

等待/唤醒机制。

涉及的方法：

1，wait(): 让线程处于冻结状态，被wait的线程会被存储到线程池中。
2，notify():唤醒线程池中一个线程(任意).
3，notifyAll():唤醒线程池中的所有线程。

这些方法都必须定义在同步中。
因为这些方法是用于操作线程状态的方法。
必须要明确到底操作的是哪个锁上的线程。

为什么操作线程的方法wait notify notifyAll定义在了Object类中？

因为这些方法是监视器的方法。监视器其实就是锁。
锁可以是任意的对象，任意的对象调用的方式一定定义在Object类中。

 

 代码优化：

 

 

 

未完......