第11章 多线程「建议收藏」

第11章 多线程「建议收藏」第11章 多线程

大家好,又见面了,我是你们的朋友全栈君。

程序、进程、线程

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

  • **进程(process)**是程序的一次执行过程或是正在运行的一个程序。动态过程:有它自身的产生、存在和消亡的过程。

如:运行中的QQ,运行中的MP3播放器。 程序是静态的,进程是动态的。

  • 线程(thread),进程可进一步细化为线程,是一个程序内部的一条执行路径。

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

进程与多线程

第11章 多线程「建议收藏」

每个Java程序都有一个隐含的主线程: main()方法

何时需要多线程

  • 程序需要同时执行两个以上任务
  • 程序需要实现一些需要等待的任务时(阻塞操作)。如用户输入、文件读写操作、网络操作、搜索等。
  • 需要一些后台运行的程序时。

多线程的创建和启动

  • Java语言的JVM允许程序运行多个线程,它通过java.lang.Thread类来实现。
  • Thread类的特性:

每个线程都是通过某个特定Thread对象的run()方法来完成操作的,经常把run()方法的主体称为线程体。 通过该Thread对象的start()方法来调用这个线程。

子线程的创建和启动过程

public class MyThread extends Thread {

    public MyThread() {
        super();
    }

    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println("子线程:" + i);
        }
    }

    public static void main(String[] args) {
        //1.创建线程
        MyThread mt = new MyThread();
        //2.启动线程,并调用当前线程的run()方法
        mt.start();
    }
}

Thread类

  • 构造方法

Thread():创建新的Thread对象。
Thread(String threadName):创建线程并指定线程实例名。
Thread(Runnable target):指定创建线程的目标对象,它实现了Runnable接口中的run()方法。
Thread(Runnable target, String threadName):创建新的Thread对象。

创建线程的两种方式

  • 继承Thread

1.定义子类,继承Thread类。
2.在子类中,重写Thread类中的run()方法。
3.创建Thread子类对象,即创建了线程对象。
4.调用线程对象start()方法:启动线程,调用run()方法。

  • 实现Runnable接口

1.定义子类,实现Runnable接口。
2.子类中重写Runnable接口中的run()方法。
3.通过Thread类含参构造器创建线程对象。
4.将Runnable接口的子类对象作为实际参数传递给Thread类的构造器中。
5.调用Thread类的start()方法:开启线程,调用Runnable子类接口的run()方法。

说明:其实除了以上两种方式外,还有两种方式用来创建线程: 1.实现Callable接口。(Callable+Future) 2.线程池。(Executor)

继承方式和实现方式的联系与区别

public class Thread extends Object implements Runnable 区别:

继承Thread:线程代码存放Thread子类run()方法中。 实现Runnable:线程代码存在接口的子类的run()方法。

实现方法的好处:(推荐实现线程的方式)

避免了单继承的局限性。 多个线程可以共享同一个接口实现类的对象,适合多个相同线程来处理同一份资源

练习

创建两个子线程,让其中一个输出1-100之间的偶数,另一个输出1-100之间的奇数。

class Thread1 implements Runnable {

    @Override
    public void run() {
        for (int i = 1; i <= 100; i++) {
            //偶数
            if (i % 2 == 0) {
                System.out.println(Thread.currentThread().getName() + "--" + i);
            }
        }
    }
}

class Thread2 implements Runnable {

    @Override
    public void run() {
        for (int i = 1; i <= 100; i++) {
             //奇数
            if (i % 2 != 0) {
                System.out.println(Thread.currentThread().getName() + "--" + i);
            }
        }
    }
}

public class Test1 {
    public static void main(String[] args) {
        Thread1 t1 = new Thread1();
        Thread2 t2 = new Thread2();
        new Thread(t1).start();
        new Thread(t2).start();
    }
}

Thread类的有关方法

  • void start(): 启动线程,并执行对象的run()方法。
  • run():线程在被调度时执行的操作。(不是运行线程的方法)
  • String getName(): 返回线程的名称
  • void setName(String name):设置该线程名称。
  • static currentThread()返回当前线程

线程的调度

  • 调度策略

时间片。 抢占式:高优先级的线程抢占CPU

  • 调度方法

同优先级线程组成先进先出队列(先到先服务),使用时间片策略。 对高优先级,使用优先调度的抢占式策略。

线程的优先级

  • 线程的优先级控制

MAX_PRIORITY:线程可以具有的最高优先级。
MIN _PRIORITY:线程可以具有的最低优先级。
NORM_PRIORITY:分配给线程的默认优先级。

涉及的方法:

  • getPriority() :返回线程优先值。
  • setPriority(int newPriority) :改变线程的优先级。

线程创建时继承父线程的优先级。

  • static native void yield():线程礼让。

暂停当前正在执行的线程,把执行机会让给优先级相同或更高的线程。 若队列中没有同优先级的线程,忽略此方法。

  • join():当某个程序执行流中调用其他线程的join()方法时,调用线程将被阻塞,直到join()方法加入的join线程执行完为止。

低优先级的线程也可以获得执行。

  • static void sleep(long millis)线程暂停 (时间单位:毫秒)

令当前活动线程在指定时间段内放弃对CPU的控制,使其他线程有机会被执行,时间到后重排队。 抛出InterruptedException异常。

  • stop(): 强制线程生命期结束。(已过时)
  • boolean isAlive():返回boolean,判断线程是否还活着。

使用多线程的优点

背景:只使用单个线程完成多个任务(调用多个方法),肯定比用多个线程来完成用的时间更短,那为何仍还需要多线程呢?

多线程程序的优点:

  • 提高应用程序的响应。对图形化界面更有意义,可增强用户体验。
  • 提高计算机系统CPU的利用率
  • 改善程序结构。将既长又复杂的进程分为多个线程,独立运行,利于理解和修改。

多线程程序的缺点:

  • 用不好,效率会降低。因为,多线程的开销要比单线程的开销大。

线程的分类

Java中的线程分为两类:一种是守护线程,一种是用户线程

  • 它们在几乎每个方面都是相同的,唯一的区别是判断JVM何时离开。
  • 守护线程是用来服务用户线程的,通过在start()方法前调用thread.setDaemon(true)可以把一个用户线程变成一个守护线程。
  • Java垃圾回收就是一个的守护线程
  • 若JVM中都是守护线程,当前JVM将退出。

线程的生命周期(了解)

JDK中用Thread.State枚举表示了线程的几种状态。

要想实现多线程,必须在主线程中创建新的线程对象。Java语言使用Thread类及其子类的对象来表示线程,在它的一个完整的生命周期中通常要经历如下的五种状态:

  • 新建: 当一个Thread类或其子类的对象被声明并创建时,新生的线程对象处于新建状态。
  • 就绪:处于新建状态的线程被start()后,将进入线程队列等待CPU时间片,此时它已具备了运行的条件。
  • 运行:当就绪的线程被调度并获得处理器资源时,便进入运行状态,run()方法定义了线程的操作和功能。
  • 阻塞:在某种特殊情况下,被人为挂起或执行输入输出操作时,让出CPU并临时中止自己的执行,进入阻塞状态。
  • 死亡:线程完成了它的全部工作或线程被提前强制性地中止 。

第11章 多线程「建议收藏」

线程的同步(重点)

问题的提出:

  • 多个线程执行的不确定性引起执行结果的不稳定。
  • 多个线程对账本的共享,会造成操作的不完整性,会破坏数据。 (多线程会对共享数据造成破坏)

第11章 多线程「建议收藏」

例题

模拟火车站售票程序,开启三个窗口售票。

class Ticket implements Runnable {
    private int tick = 100;
    @Override
    public void run() {
        while (true) {
            if (tick > 0) {
                System.out.println(Thread.currentThread().getName() + "售出车票,tick号为:" + tick--);
            } else {
                break;
            }
        }
    }
}

public class TicketDemo {
    public static void main(String[] args) {
        Ticket t = new Ticket();
        new Thread(t, "t1窗口").start();
        new Thread(t, "t2窗口").start();
        new Thread(t, "t3窗口").start();
    }
}

第11章 多线程「建议收藏」

第11章 多线程「建议收藏」

private int tick = 100;
    public void run() {
        while (true) {
            if (tick > 0) {
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + "售出车票,tick号为:" + tick--);
            }
        }
    }

多线程安全问题

  • 问题的原因:

当多条语句在操作同一个线程的共享数据时,一个线程对多条语句只执行了一部分,还没有执行完,另一个线程参与进来执行,导致共享数据的错误。

  • 解决办法:

对多条操作共享数据的语句,只能让一个线程都执行完,在执行过程中,其他线程不可以参与执行。 1.同步代码块 2.同步方法 3.Lock

Synchronized的使用方法

Java对于多线程的安全问题提供了专业的解决方式:同步机制

  • 同步代码块
synchronized(对象){
  // 需要被同步的代码
}
  • 同步方法
public synchronized void 方法名 (参数列表){ 
   // 业务代码
}

分析同步原理

第11章 多线程「建议收藏」

互斥锁

在Java语言中,引入了对象互斥锁的概念,来保证共享数据操作的完整性

  • 每个对象都对应于一个可称为“互斥锁”的标记,这个标记用来保证在任一时刻,只能有一个线程访问该对象
  • 关键字synchronized来与对象的互斥锁联系。 当某个对象用synchronized修饰时,表明该对象在任一时刻只能由一个线程访问。
  • 同步的局限性:导致程序的执行效率降低
  • 同步方法(非静态的)的锁为this
  • 同步方法(静态的)的锁为当前类本身。(类名.class)

单例设计模式之懒汉式

class Singleton {
    private static Singleton instance = null;
    private Singleton() {
    }
    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);
    }
}

练习

银行有一个账户。 有两个储户分别向同一个账户存3000元,每次存1000,存3次。每次存完打印账户余额。 问题:该程序是否有安全问题,如果有,如何解决? 提示: 1、明确哪些代码是多线程运行代码,须写入run()方法。 2、明确什么是共享数据。 3、明确多线程运行代码中哪些语句是操作共享数据的。

class Account {
    private int balance; //余额
    //存钱
    public synchronized void deposit(int amt) {
        balance += amt;
        try {
            //必须有。体现“每次”。
            Thread.currentThread().sleep(10);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + ":" + balance);
    }
}

class Customer implements Runnable {
    private Account account; //每个储户都有一个账户
    public Customer(Account account) {
        this.account = account;
    }
    @Override
    public void run() {
        for (int i = 1; i <= 3; i++) {
            try {
                //必须有。体现“每次”。
                Thread.currentThread().sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            account.deposit(1000);
        }
    }
}

public class BankTest {
    public static void main(String[] args) {
        Account a = new Account();
        Customer c1 = new Customer(a);
        Customer c2 = new Customer(a);

        Thread t1 = new Thread(c1,"张三");
        Thread t2 = new Thread(c2,"李四");

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

拓展问题:可否实现两个储户交替存钱的操作。需要使用线程通信!

小结:释放锁的操作

  • 当前线程的同步方法、同步代码块执行结束。
  • 当前线程在同步代码块、同步方法中遇到breakreturn终止了该代码块、该方法的继续执行。
  • 当前线程在同步代码块、同步方法中出现了未处理的Error或Exception,导致异常结束。
  • 当前线程在同步代码块、同步方法中执行了线程对象的wait()方法,当前线程暂停,并释放锁。

小结:不会释放锁的操作

  • 线程执行同步代码块或同步方法时,程序调用Thread.sleep()Thread.yield()方法暂停当前线程的执行。
  • 线程执行同步代码块时,其他线程调用了该线程的suspend()方法将该线程挂起,该线程不会释放锁(同步监视器)。

应尽量避免使用suspend()resume()来控制线程。 这两个方法已过时。

线程的死锁问题

  • 死锁

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

  • 解决方法

专门的算法、原则。 尽量减少同步资源的定义

例:

class A {
	public synchronized void foo(B b) {
		System.out.println("当前线程名: " + Thread.currentThread().getName()
				+ " 进入了A实例的foo方法"); // ①
		try {
			Thread.sleep(200);
		} catch (InterruptedException ex) {
			ex.printStackTrace();
		}
		System.out.println("当前线程名: " + Thread.currentThread().getName()
				+ " 企图调用B实例的last方法"); // ③
		b.last();
	}
	public synchronized void last() {
		System.out.println("进入了A类的last方法内部");
	}
}

class B {
	public synchronized void bar(A a) {
		System.out.println("当前线程名: " + Thread.currentThread().getName()
				+ " 进入了B实例的bar方法"); // ②
		try {
			Thread.sleep(200);
		} catch (InterruptedException ex) {
			ex.printStackTrace();
		}
		System.out.println("当前线程名: " + Thread.currentThread().getName()
				+ " 企图调用A实例的last方法"); // ④
		a.last();
	}
	public synchronized void last() {
		System.out.println("进入了B类的last方法内部");
	}
}

public class DeadLock implements Runnable {
	A a = new A();
	B b = new B();
	public void init() {
		Thread.currentThread().setName("主线程");
		// 调用a对象的foo方法
		a.foo(b);
		System.out.println("进入了主线程之后");
	}
	public void run() {
		Thread.currentThread().setName("副线程");
		// 调用b对象的bar方法
		b.bar(a);
		System.out.println("进入了副线程之后");
	}
	public static void main(String[] args) {
		DeadLock dl = new DeadLock();
		new Thread(dl).start();
		dl.init();
	}
}
public class TestDeadLock {

    static StringBuffer s1 = new StringBuffer();
    static StringBuffer s2 = new StringBuffer();

    public static void main(String[] args) {
        
        new Thread() {
            public void run() {
                synchronized (s1) {
                    s2.append("A");
                    synchronized (s2) {
                        s2.append("B");
                        System.out.print(s1);
                        System.out.print(s2);
                    }
                }
            }
        }.start();
        
        new Thread() {
            public void run() {
                synchronized (s2) {
                    s2.append("C");
                    synchronized (s1) {
                        s1.append("D");
                        System.out.print(s2);
                        System.out.print(s1);
                    }
                }
            }
        }.start();
    }
}

线程通信

  • wait():令当前线程挂起并放弃CPU、同步资源,使别的线程可访问并修改共享资源,而当前线程排队等候再次对资源的访问。
  • notify()唤醒正在排队等待同步资源的线程中优先级最高者结束等待。
  • notifyAll()唤醒正在排队等待资源的所有线程结束等待。

java.lang.Object提供的这三个方法只有在同步方法同步代码块中才能使用,否则会报java.lang.IllegalMonitorStateException异常。

wait() 方法

  • 在当前线程中调用方法:对象名.wait()
  • 功能:使当前线程进入等待/挂起(某对象)状态 ,直到另一线程对该对象发出notify()(或notifyAll()) 为止。
  • 调用方法的必要条件:当前线程必须具有对该对象的监控权(加锁)。
  • 调用此方法后,当前线程将释放对象监控权 ,然后进入等待。
  • 在当前线程被notify后,要重新获得监控权,然后从断点处继续代码的执行。

notify()、notifyAll()

  • 在当前线程中调用方法:对象名.notify()
  • 功能:唤醒等待该对象监控权的一个线程。
  • 调用方法的必要条件:当前线程必须具有对该对象的监控权(加锁)。

例题

使用两个线程打印 1-100。线程1,线程2 交替打印。

public class Communication implements Runnable {

    private int i = 1;
    
    @Override
    public void run() {
        while (true) {
            synchronized (this) {
                notify();
                if (i <= 100) {
                    System.out.println(Thread.currentThread().getName() + ":" + i++);
                } else {
                   break;
                }
                try {
                    wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    public static void main(String[] args) {
        Communication c = new Communication();
        new Thread(c).start();
        new Thread(c).start();
    }
}

经典例题:生产者/消费者问题

生产者(Productor)将产品交给店员(Clerk),而消费者(Consumer)从店员处取走产品。 店员一次只能持有固定数量的产品(比如:20)。 1.如果生产者试图生产更多的产品,店员会叫生产者停一下,当店中有空位放产品了,再通知生产者继续生产; 2.如果店中没有产品了,店员会告诉消费者等一下,当店中有产品了再通知消费者来取走产品。

这里可能出现两个问题:

  • 生产者比消费者快时,消费者会漏掉一些数据没有取到。
  • 消费者比生产者快时,消费者会取相同的数据。
class Clerk {  //售货员
    private int product = 0;

    public synchronized void addProduct() {
        if (product >= 20) {
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        } else {
            product++;
            System.out.println("生产者生产了第" + product + "个产品");
            notifyAll();
        }
    }

    public synchronized void getProduct() {
        if (this.product <= 0) {
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        } else {
            System.out.println("消费者取走了第" + product + "个产品");
            product--;
            notifyAll();
        }
    }
}

class Productor implements Runnable {  //生产者
    Clerk clerk;

    public Productor(Clerk clerk) {
        this.clerk = clerk;
    }

    public void run() {
        System.out.println("生产者开始生产产品");
        while (true) {
            try {
                Thread.sleep((int) Math.random() * 1000);
            } catch (InterruptedException e) {
            }
            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.sleep((int) Math.random() * 1000);
            } catch (InterruptedException e) {
            }
            clerk.getProduct();
        }
    }
}

public class TestProduct {
    public static void main(String[] args) {
        Clerk clerk = new Clerk();
        Thread productorThread = new Thread(new Productor(clerk));
        Thread consumerThread = new Thread(new Consumer(clerk));
        productorThread.start();
        consumerThread.start();
    }
}

练习

模拟银行取钱的问题 1.定义一个Account类 1)该Account类封装了账户编号(String)和余额(double)两个属性 2)设置相应属性的getter和setter方法 3)提供无参和有两个参数的构造器 4)系统根据账号判断与用户是否匹配,需提供hashCode()和equals()方法的重写 2.提供一个取钱的线程类 1)提供了Account类的account属性和double类的取款额的属性 2)提供带线程名的构造方法 3)run()方法中提供取钱的操作 3.在主类中创建线程进行测试。考虑线程安全问题。

class Account {
    private String accountId;
    private double balance;

    public Account() {
    }

    public Account(String accountId, double balance) {
        this.accountId = accountId;
        this.balance = balance;
    }

    public String getAccountId() {
        return accountId;
    }

    public void setAccountId(String accountId) {
        this.accountId = accountId;
    }

    public double getBalance() {
        return balance;
    }

    public void setBalance(double balance) {
        this.balance = balance;
    }

    public String toString() {
        return "Account [accountId=" + accountId + ", balance=" + balance + "]";
    }

    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result
                + ((accountId == null) ? 0 : accountId.hashCode());
        long temp;
        temp = Double.doubleToLongBits(balance);
        result = prime * result + (int) (temp ^ (temp >>> 32));
        return result;
    }

    public boolean equals(Object obj) {
        if (this == obj) return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        Account other = (Account) obj;
        if (accountId == null) {
            if (other.accountId != null) return false;
        } else if (!accountId.equals(other.accountId))
            return false;
        if (Double.doubleToLongBits(balance) != Double
                .doubleToLongBits(other.balance))
            return false;
        return true;
    }
}

class WithDrawThread extends Thread {
    Account account;
    //要取款的额度
    double withDraw;

    public WithDrawThread(String name, Account account, double amt) {
        super(name);
        this.account = account;
        this.withDraw = amt;
    }

    public void run() {
        synchronized (account) {
            if (account.getBalance() > withDraw) {
                System.out.println(Thread.currentThread().getName()
                        + ":取款成功,取现的金额为:" + withDraw);
                try {
                    Thread.sleep(50);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                account.setBalance(account.getBalance() - withDraw);
            } else {
                System.out.println("取现额度超过账户余额,取款失败");
            }
            System.out.println("现在账户的余额为:" + account.getBalance());
        }
    }
}

public class TestWithDrawThread {
    public static void main(String[] args) {
        Account account = new Account("1234567", 10000);
        Thread t1 = new WithDrawThread("小明", account, 8000);
        Thread t2 = new WithDrawThread("小明's wife", account, 2800);
        t1.start();
        t2.start();
    }
}

转载于:https://my.oschina.net/mondayer/blog/3028355

版权声明:本文内容由互联网用户自发贡献,该文观点仅代表作者本人。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容, 请发送邮件至 举报,一经查实,本站将立刻删除。

发布者:全栈程序员-用户IM,转载请注明出处:https://javaforall.cn/106913.html原文链接:https://javaforall.cn

【正版授权,激活自己账号】: Jetbrains全家桶Ide使用,1年售后保障,每天仅需1毛

【官方授权 正版激活】: 官方授权 正版激活 支持Jetbrains家族下所有IDE 使用个人JB账号...

(0)


相关推荐

发表回复

您的电子邮箱地址不会被公开。

关注全栈程序员社区公众号