JavaSE 基础笔记之多线程

基本概念：程序、进程、线程

程序（program）是为完成特定任务、用某种语言编写的一组指令的集合。即指一段静态的代码，静态对象。

进程（process）：是程序的一次执行过程，或是正在运行的一个程序。动态过程：有它自身的产生、存在和消亡的过程

程序是静态的，进程是动态的。

线程（thread）：进程可进一步细化为线程，是一个程序内部的一条执行路径。

若一个程序可同一时间执行多个线程，就是支持多线程的。

何时需要多线程

1.程序需要同时执行两个或多个任务。

2.程序需要实现一些需要等待的任务时，如用户输入、文件读写操作、网络操作、搜索等。

3.需要一些后台运行的程序时。

---

多线程的创建和启动

Java语言的JVM允许程序运行多个线程，它通过java.lang.Thread类来实现

Thread类的特性

每个线程都是通过某个特定Thread类对象的run()方法来完成操作的，经常把run()方法的主题称为线程体。

通过Thread对象的start()方法来调用这个线程

一、继承的方式创建多线程

package com.robin.java;

/*
 * 创建一个子线程，完成1-100之间自然数的输出，同样地，主线程执行同样的操作
 * 创建多线程的第一个方式：继承java.lang.Thread类
 */
//1.创建一个继承于Thread的子类
class SubThread extends Thread{
    //2.重写Thread类的run()方法,方法内实现此子线程要完成的功能
    public void run(){
        for(int i = 1; i <= 100; i++){
            System.out.println(Thread.currentThread().getName() + ":" + i);
        }
    }
}
public class TestThread {
    public static void main(String[] args){
        //3.创建子类的对象
        SubThread st1 = new SubThread();
        SubThread st2 = new SubThread();
        //4.调用线程的start()方法：启动此线程；调用相应的run()方法
        st1.start();
        st2.start();
        //5.一个线程只能执行一次start()
//        st.start();//异常：IllegalThreadStateException
//        st.run();  //不能通过Thread实现类对象的run()去启动一个线程
        for(int i = 1; i <= 100; i++){
            System.out.println(Thread.currentThread().getName() + ":" + i);
        }
    }
}

---

Thread的常用方法

package com.robin.java;

/*
 * Thread的常用方法：
 * 1.start()：启动线程并执行相应的run()方法
 * 2.run()：子线程要执行的代码放入run()方法中.
 * 3.currentThread()：静态的，调取当前的线程
 * 4.getName()：获取此线程的名字
 * 5.setName()：设置此线程的名字
 * 6.yield()：调用此方法的线程释放当前cpu的执行权
 * 7.join()：在A线程中调用B线程的join()方法，表示，当执行到此方法，A线程停止执行，直至B线程执行完毕，A线程再接着join()之后的代码执行
 * 8.isAlive()：判断当前线程是否还存活
 * 9.sleep(long l)：显式的让当前线程睡眠l毫秒
 * 10.线程通信：wait()   notify()  notifyAll()
 * 
 * 设置线程的优先级
 * MAX_PRIORITY(10)
 * MIN_PRIORITY(1)
 * NORM_PRIORITY(5)
 * getPriority():返回线程优先级
 * setPriority(int newPriority)：改变线程的优先级
 * 线程创建时继承父线程的优先级
 */
class SubThread1 extends Thread{
    public void run(){
        for(int i = 1; i <= 100; i++){
//            try {
//                Thread.currentThread().sleep(1000);
//            } catch (InterruptedException e) {
//                // TODO Auto-generated catch block
//                e.printStackTrace();
//            }
            System.out.println(Thread.currentThread().getName() + ":" + Thread.currentThread().getPriority() + ":" + i);
        }
    }
}
public class TestThread2 {
    public static void main(String[] args){
        SubThread1 st1 = new SubThread1();
        st1.setName("子线程1");
        st1.setPriority(Thread.MAX_PRIORITY);
        st1.start();
        Thread.currentThread().setName("------主线程");
        for(int i = 1; i <= 100; i++){
            System.out.println(Thread.currentThread().getName() + ":" + Thread.currentThread().getPriority() + ":" + i);
//            if(i % 10 == 0){
//                Thread.currentThread().yield();
//            }
//            if(i == 20){
//                try {
//                    st1.join();
//                } catch (InterruptedException e) {
//                    // TODO Auto-generated catch block
//                    e.printStackTrace();
//                }
//            }
        }
        System.out.println(st1.isAlive());
    }
}

---

练习

package com.robin.exer;
/*
 * 创建两个子线程，让其中一个输出1-100之间的偶数，另一个输出1-100之间的奇数。
 */
class SubThread1 extends Thread{
    public void run(){
        for(int i = 1; i <= 100; i++){
            if(i % 2 == 0){
                System.out.println(Thread.currentThread().getName() + ":" + i);
            }
        }
    }
}

class SubThread2 extends Thread{
    public void run(){
        for(int i = 1; i <= 100; i++){
            if(i % 2 != 0){
                System.out.println(Thread.currentThread().getName() + ":" + i);
            }
        }
    }
}
public class Exer1 {
    public static void main(String[] args) {
        SubThread1 st1 = new SubThread1();
        SubThread2 st2 = new SubThread2();
        st1.start();
        st2.start();
        //继承于Thread类的匿名类的对象
//        new Thread(){
//            public void run(){
//                for(int i = 1; i <= 100; i++){
//                    if(i % 2 == 0){
//                        System.out.println(Thread.currentThread().getName() + ":" + i);
//                    }
//                }
//            }
//        }.start();
//        new Thread(){
//            public void run(){
//                for(int i = 1; i <= 100; i++){
//                    if(i % 2 != 0){
//                        System.out.println(Thread.currentThread().getName() + ":" + i);
//                    }
//                }
//            }
//        }.start();
    }
} 

---

多窗口售票

package com.robin.java;

//模拟火车站售票窗口，开启三个窗口售票，总票数100张。

public class TestWindow {
    public static void main(String[] args) {
        Window w1 = new Window();
        Window w2 = new Window();
        Window w3 = new Window();
        
        w1.setName("窗口1");
        w2.setName("窗口2");
        w3.setName("窗口3");
        
        w1.start();
        w2.start();
        w3.start();
    }
}

class Window extends Thread{
    static int ticket = 100;
    public void run(){
        while(true){
            if(ticket > 0){
                System.out.println(Thread.currentThread().getName() + "售票，票号为：" + ticket--);
            }else{
                break;
            }
        }
    }
}

---

二、实现的方式创建多线程

 

package com.robin.java;

/*
 * 创建多线程的方式二：通过实现的方方式
 * 
 * 对比一下继承的方式  vs  实现的方式
 * 1.联系：public class Thread implements Runnable
 * 2.哪个方式好？实现的方式优于继承的方式
 *    why？ ①避免了java中单继承的局限性
 *         ②如果多个线程要操作同一份资源（数据），更适合使用实现的方式
 */
//1.创建一个实现了Runnable接口的类
class PrintNum1 implements Runnable{

    //实现接口的抽象方法
    @Override
    public void run() {
        // TODO Auto-generated method stub
        for(int i = 1; i <= 100; i++){
            System.out.println(Thread.currentThread().getName() + ":" + i);
        }
    }
    
}
public class TestThread1 {
    public static void main(String[] args) {
        //3.创建一个Runnable接口实现类的对象
        PrintNum1 p = new PrintNum1();
        //要想启动一个多线程，必须调用start()方法
        //4.将此对象作为形参传递给Thread类的构造器中，创建Thread类的对象，此对象即为一个线程
        Thread  t1 = new Thread(p);
        //5.调用start()方法，启动线程并执行run()
        t1.start();//启动线程，执行Thread对象生成时构造器形参的对象的run()方法。
    }
}

多窗口售票

package com.robin.exer;

//使用 实现Runnable接口的方式：售票

class Window1 implements Runnable{
    int ticket = 100;
    public void run(){
        while(true){
            if(ticket > 0){
                System.out.println(Thread.currentThread().getName() + "售票，票号为：" + ticket--);
            }else{
                break;
            }
        }
    }
}
public class Exer2 {
    public static void main(String[] args) {
        Window1 w = new Window1();
        Thread t1 = new Thread(w);
        Thread t2 = new Thread(w);
        Thread t3 = new Thread(w);
        
        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");
        
        t1.start();
        t2.start();
        t3.start();
    }
    
}

---

使用多线程的优点

1.提高应用程序的响应。对图形化界面更有意义，可增强用户体验

2.提高计算机系统CPU的利用率

3.改善程序结构。将既长又复杂的进程分为多个线程，独立运行，利于理解和修改。

---

线程的分类

java中的线程分为两类：一种是守护线程，一种是用户线程。

>它们在几乎每个方面都是相同的，唯一的区别是判断JVM何时离开。

>守护线程是用来服务用户线程的，通过在start()方法前调用thread.setDaemon(true)可以把一个用户线程变成一个守护线程。

>java垃圾回收就是一个典型的守护线程。

>若JVM中都是守护线程，当前JVM将退出。

---

线程的生命周期

五种状态：新建，就绪，运行，阻塞，死亡

 

 线程的同步机制

package com.robin.exer;

//使用 实现Runnable接口的方式：售票
/*
 * 此程序存在线程安全问题：打印车票时，会出现重票、错票
 * 1.线程安全问题存在的原因？
 *   由于一个线程在操作共享数据的过程中，未执行完的情况下，另外的线程参与进来，导致共享数据存在安全问题
 *   
 * 2.如何解决线程的安全问题？
 *   必须让一个线程操作共享数据完毕以后，其他线程才有机会参与共享数据的操作。
 *   
 * 3.java如何实现线程的安全：线程的同步机制
 *     方式一：同步代码块
 *     synchronized(同步监视器){
 *         //需要被同步的代码块（即为操作共享数据的代码块）
 *     }
 *     1.共享数据：多个线程共同来操作的同一个数据（变量）
 *     2.同步监视器：由一个类的对象来充当。哪个线程获取此监视器，谁就执行大括号里被同步的代码。俗称：锁
 *     要求：所有的线程必须共用同一把锁！
 *     注：在实现的方式中，考虑同步的话，可以使用this来充当锁。但是在继承的方式中，慎用this
 *     方式二：同步方法
 *     将操作共享数据的方法声明为synchronized。即此方法为同步方法，能够保证当其中一个线程
 *     执行此方法时，其他线程在外等待直至此线程执行完此方法。
 *     >同步方法的锁：this
 */
class Window3 implements Runnable{
    int ticket = 100;    //共享数据
    Object obj = new Object();
//    Animal a = new Animal();
    public void run(){
        while(true){
            show();
        }
    }
    通过同步方法的方式
    public synchronized void show(){
        if(ticket > 0){
            try {
                Thread.currentThread().sleep(10);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "售票，票号为：" + ticket--);
        }
    }
}
public class Exer4 {
    public static void main(String[] args) {
        Window3 w = new Window3();
        Thread t1 = new Thread(w);
        Thread t2 = new Thread(w);
        Thread t3 = new Thread(w);
        
        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");
        
        t1.start();
        t2.start();
        t3.start();
    }
}

class Window2 implements Runnable{
    int ticket = 100;    //共享数据
    Object obj = new Object();
    Animal a = new Animal();
    public void run(){
        while(true){
         通过同步代码块方式
            synchronized(this){//this表示当前对象，本题中即为w
                if(ticket > 0){
                    try {
                        Thread.currentThread().sleep(10);
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + "售票，票号为：" + ticket--);
                }
            }
        }
    }
}
public class Exer3 {
    public static void main(String[] args) {
        Window2 w = new Window2();
        Thread t1 = new Thread(w);
        Thread t2 = new Thread(w);
        Thread t3 = new Thread(w);
        
        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");
        
        t1.start();
        t2.start();
        t3.start();
    }
}

---

互斥锁

package com.robin.java;

//关于懒汉式的线程安全问题：使用同步机制
//对于一般的方法内，使用同步代码块，可以考虑使用this。
//对于静态方法而言，使用当前类本身充当锁。
/*
 * 线程的同步的弊端：由于同一个时间只能有一个线程访问共享数据，效率变低了。
 */
class Singleton{
    private Singleton(){
        
    }
    
    private static Singleton instance = null;
    
    public static Singleton getInstance(){
        if(instance == null){
            synchronized(Singleton.class){
                if(instance == null){
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

public class TestSingleton {

    public static void main(String[] args) {
        Singleton s1 = Singleton.getInstance();
        Singleton s2 = Singleton.getInstance();
        System.out.println(s1 == s2);
    }
}

---

练习

package com.robin.exer;

/*
 * 银行有一个账户。
 * 有两个储户分别向同一个账户存3000元，每次存1000，存3次。每次存完打印账户余额。
 * 
 * 1.是否涉及到多线程？
 * 是！有两个储户（两种方式创建多线程）
 * 2.是否有共享数据？
 * 有！同一个账户
 * 3.得考虑线程的同步。（两种方法处理线程的安全）
 */

class Account{
    double balance;
    
    public void setMoney(double amt){
        synchronized(this){
            balance += amt;
            try {
                Thread.currentThread().sleep(10);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + ":" + balance);
        }
        
    }
}

class Custormer implements Runnable{

    Account acc;
    public Custormer(Account acc){
        this.acc = acc;
    }
    @Override
    public void run() {
        for(int i = 0; i < 3; i++){
            acc.setMoney(1000);
        }
    }
    
}

public class Exer5 {
    public static void main(String[] args) {
        Account acc = new Account();
        Custormer c1 = new Custormer(acc);
        Custormer c2 = new Custormer(acc);
        Thread t1 = new Thread(c1);
        Thread t2 = new Thread(c2);
        
        t1.setName("储户A");
        t2.setName("储户B");
        
        t1.start();
        t2.start();
    }
}

---

线程的死锁

死锁：不同的线程分别占用对方需要的同步资源不放弃，都在等待对方放弃自己需要的同步资源，就形成了线程的死锁。

解决方法：专门的算法、原则；尽量减少同步资源的定义

package com.robin.java;

//死锁的问题：处理线程同步时容易出现。
public class TestDeadLock {

    static StringBuffer sb1 = new StringBuffer();
    static StringBuffer sb2 = new StringBuffer();
    
    public static void main(String[] args) {
        new Thread(){
            public void run(){
                synchronized(sb1){
                    try {
                        Thread.currentThread().sleep(10);
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                    sb1.append("A");
                    synchronized(sb2){
                        sb2.append("B");
                        System.out.println(sb1);
                        System.out.println(sb2);
                    }
                }
            }
        }.start();
        new Thread(){
            public void run(){
                synchronized(sb2){
                    try {
                        Thread.currentThread().sleep(10);
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                    sb1.append("C");
                    synchronized(sb1){
                        sb2.append("D");
                        System.out.println(sb1);
                        System.out.println(sb2);
                    }
                }
            }
        }.start();
    }
    
}

---

 线程通信

package com.robin.java;
//线程通信：如下的三个关键字使用的话，都得在同步代码块或同步方法中。
//wait()：一旦一个线程执行到wait(),就释放当前的锁
//notify()/notifyAll():唤醒wait的用一个或所有的锁。
//使用两个线程打印1-100，线程1，线程2 交替打印

class PrintNum implements Runnable{
    int num = 1;
    public void run(){
        while(true){
            synchronized (this) {
                notify();
                if (num <= 100) {
                    System.out.println(Thread.currentThread().getName() + ":" + num);
                    num++;
                } else {
                    break;
                }
                try {
                    wait();
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
        }
    }
}

public class TestCommunication {
    public static void main(String[] args) {
        PrintNum p = new PrintNum();
        Thread t1 = new Thread(p);
        Thread t2 = new Thread(p);
        
        t1.setName("A");
        t2.setName("B");
        
        t1.start();
        t2.start();
    }
}

---

经典例题：生产者和消费则问题

package com.robin.java;

/*
 * 生产者(Productor)将产品交给店员(Clerk)，
 * 而消费者(Customer)从店员处取走产品，
 * 店员一次只能持有固定数量的产品(比如:20），
 * 如果生产者试图生产更多的产品，店员会叫生产者停一下，
 * 如果店中有空位放产品了再通知生产者继续生产；
 * 如果店中没有产品了，店员会告诉消费者等一下，
 * 如果店中有产品了再通知消费者来取走产品。
 * 
 * 分析：
 * 1.是否涉及到多线程的问题？ 是！生产者、消费者
 * 2.是否涉及到共享数据？有！
 * 3.此共享数据是谁？即为产品数量。
 * 4.是否涉及到线程的通信呢？存在着生产者与消费者的通信。
 */

class Clerk{ //店员
    int product;
    
    public synchronized void addProduct(){ //生产产品
        if(product >= 20){
            try {
                wait();
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }else{
            product++;
            System.out.println(Thread.currentThread().getName() + "生产了第" + product + "个产品");
            notifyAll();
        }
    }
    
    public synchronized void consumeProduct(){//消费产品
        if(product <= 0) {
            try {
                wait();
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }else{
            System.out.println(Thread.currentThread().getName() + "消费了第" + product + "个产品");
            product--;
            notifyAll();
        }
    }
}

class Producer implements Runnable{ //生产者
    Clerk clerk;
    
    public Producer(Clerk clerk){
        this.clerk = clerk;
    }
    
    public void run(){
        System.out.println("生产者开始生产产品");
        while(true){
            try {
                Thread.currentThread().sleep(100);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            clerk.addProduct();
        }
    }
}

class Consumer implements Runnable{ //消费者
    Clerk clerk;
    public Consumer(Clerk clerk){
        this.clerk = clerk;
    }
    
    public void run (){
        System.out.println("消费者消费产品");
        while(true){
            try {
                Thread.currentThread().sleep(100);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            clerk.consumeProduct();
        }
    }
}

public class TestProduceConsume {
    public static void main(String[] args) {
        Clerk clerk = new Clerk();
        Producer p1 = new Producer(clerk);
        Consumer c= new Consumer(clerk);
        Thread t1 = new Thread(p1);//一个生产者的线程
        Thread t2 = new Thread(c); // 一个消费者的线程
        Thread t3 = new Thread(p1);//一个生产者的线程
        
        t1.setName("生产者1");
        t2.setName("消费者1");
        t3.setName("生产者2");
        
        t1.start();
        t2.start();
        t3.start();
    }
}