大家好,又见面了,我是你们的朋友全栈君。
程序、进程、线程
-
程序(program)是为完成特定任务、用某种语言编写的一组指令的集合。即指一段静态的代码,静态对象。
-
**进程(process)**是程序的一次执行过程或是正在运行的一个程序。动态过程:有它自身的产生、存在和消亡的过程。
如:运行中的QQ,运行中的MP3播放器。 程序是静态的,进程是动态的。
- 线程(thread),进程可进一步细化为线程,是一个程序内部的一条执行路径。
若一个程序可同一时间执行多个线程,就是支持多线程的。
进程与多线程
每个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并临时中止自己的执行,进入阻塞状态。
- 死亡:线程完成了它的全部工作或线程被提前强制性地中止 。
线程的同步(重点)
问题的提出:
- 多个线程执行的不确定性引起执行结果的不稳定。
- 多个线程对账本的共享,会造成操作的不完整性,会破坏数据。 (多线程会对共享数据造成破坏)
例题
模拟火车站售票程序,开启三个窗口售票。
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();
}
}
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 方法名 (参数列表){
// 业务代码
}
分析同步原理
互斥锁
在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();
}
}
拓展问题:可否实现两个储户交替存钱的操作。需要使用线程通信!
小结:释放锁的操作
- 当前线程的同步方法、同步代码块执行结束。
- 当前线程在同步代码块、同步方法中遇到
break
、return
终止了该代码块、该方法的继续执行。 - 当前线程在同步代码块、同步方法中出现了未处理的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账号...