Java_21_多线程01
多线程
什么是进程？
程序是静止的，运行中的程序就是进程。进程的三个特征：
- 动态性 ： 进程是运行中的程序，要动态的占用内存，CPU和网络等资源。
- 独立性 ： 进程与进程之间是相互独立的，彼此有自己的独立内存区域。
- 并发性 ： 假如CPU是单核，同一个时刻其实内存中只有一个进程在被执行。
CPU会分时轮询切换依次为每个进程服务，因为切换的速度非常
快，给我们的感觉这些进程在同时执行，这就是并发性。并行:同一个时刻同时有多个在执行。
什么是线程？
线程是属于进程的。一个进程可以包含多个线程，这就是多线程。
线程是进程中的一个独立执行单元。
线程创建开销相对于进程来说比较小。
线程也支持“并发性”。线程的作用：
可以提高程序的效率，线程也支持并发性，可以有更多机会得到CPU。
多线程可以解决很多业务模型。
大型高并发技术的核心技术。
设计到多线程的开发可能都比较难理解。
多线程是很有用的，我们在进程中创建线程的方式有三种:
（1）直接定义一个类继承线程类Thread，重写run()方法，创建线程对象
调用线程对象的start()方法启动线程。
（2）定义一个线程任务类实现Runnable接口，重写run()方法，创建线程任务对象，把
线程任务对象包装成线程对象， 调用线程对象的start()方法启动线程。
（3）实现Callable接口（拓展）。
线程的创建方式
多线程是很有用的，我们在进程中创建线程的方式有三种:
（1）直接定义一个类继承线程类Thread，重写run()方法，创建线程对象
调用线程对象的start()方法启动线程。
（2）定义一个线程任务类实现Runnable接口，重写run()方法，创建线程任务对象，把
线程任务对象包装成线程对象， 调用线程对象的start()方法启动线程。
（3）实现Callable接口（拓展）。
创建方式一
继承Thread类的方式
- 定义一个线程类继承Thread类。
- 重写run()方法
- 创建一个新的线程对象。
- 调用线程对象的start()方法启动线程。
继承Thread类的优缺点：
- 优点：编码简单。
- 缺点：线程类已经继承了Thread类无法继承其他类了，功能不能通过继承拓展（单继承的局限性）
小结：线程类是继承了Thread的类。
启动线程必须调用start()方法。
多线程是并发抢占CPU执行，所以在执行的过程中会出现并发随机性。
注意事项
- 线程的启动必须调用start()方法。否则当成普通类处理。
- 如果线程直接调用run()方法，相当于变成了普通类的执行，此时将只有主线程在执行他们！
- start()方法底层其实是给CPU注册当前线程，并且触发run()方法执行- 建议线程先创建子线程，主线程的任务放在之后。否则主线程永远是先执行完！
线程常用的API
Thread类的API:
- public void setName(String name):给当前线程取名字。
- public void getName():获取当前线程的名字。
– 线程存在默认名称，子线程的默认名称是：Thread-索引。
– 主线程的默认名称就是：main- public static Thread currentThread()
– 获取当前线程对象，这个代码在哪个线程中，就得到哪个线程对象。
public class ThreadDemo01 {
//启动后的ThreadDemo当成一个进程
// main方法是由主线程执行的，理解成main方法就是一个主线程
public static void main(String[] args){
//创建线程对象
Thread t = new MyThread();
t.setName("Thread-01");
//启动线程
t.start();
Thread t1 = new MyThread();
t1.setName("Thread-02");
t1.start();
for(int i = 0;i < 50;i ++) System.out.println(Thread.currentThread().getName() + "==>" + i);
}
}
//定义一个线程类继承Thread类
class MyThread extends Thread{
//重写run方法
@Override
public void run(){
//线程的执行方法
for(int i = 0;i < 50; i ++){
System.out.println(Thread.currentThread().getName() + "==>" + i);
}
}
}
线程休眠
public static void sleep(long time): 让当前线程休眠多少毫秒再继续执行。
public class ThreadDemo02 {
public static void main(String[] aregs){
for(int i = 0;i < 10;i ++){
System.out.println(i);
try{
Thread.sleep(1000);
}catch(Exception e){
e.printStackTrace();
}
}
}
}
通过有参构造器取名字
通过Thread类的有参数构造器为当前线程对象取名字。
– public Thread()
– public Thread(String name):创建线程对象并取名字。
创建方式二
多线程是很有用的，我们在进程中创建线程的方式有三种:
（1）直接定义一个类继承线程类Thread，重写run()方法，创建线程对象
调用线程对象的start()方法启动线程。
（2）定义一个线程任务类实现Runnable接口，重写run()方法，创建线程任务对象，把
线程任务对象包装成线程对象， 调用线程对象的start()方法启动线程。
（3）实现Callable接口（拓展）。实现Runnable接口的方式。
- 创建一个线程任务类实现Runnable接口。
- 重写run()方法
- 创建一个线程任务对象。
- 把线程任务对象包装成线程对象
- 调用线程对象的start()方法启动线程。
Thread的构造器：
– public Thread(){}
– public Thread(String name){}
– public Thread(Runnable target){}
– public Thread(Runnable target,String name){}实现Runnable接口创建线程的优缺点：
缺点：代码复杂一点。
优点：
- 线程任务类只是实现了Runnable接口，可以继续继承其他类，而且可以继续实现其他接口（避免了单继承的局限性）
- 同一个线程任务对象可以被包装成多个线程对象
- 适合多个多个线程去共享同一个资源（后面内容）
- 实现解耦操作，线程任务代码可以被多个线程共享，线程任务代码和线程独立。
- 线程池可以放入实现Runable或Callable线程任务对象。(后面了解)
注意：其实Thread类本身也是实现了Runnable接口的。
– 不能直接得到线程执行的结果！
//实现Runnable接口的方式创建线程
public class ThreadDemo03 {
public static void main(String[] args){
//3.创建线程任务对象 不是线程对象 仅负责执行线程任务
Runnable target = new MyRunnable();
//4.将线程任务对象包装成线程对象
Thread t = new Thread(target,"Thread-01");
//5.调用start启动线程
t.start();
//主线程任务
for(int i = 0;i < 50;i ++)
System.out.println(Thread.currentThread().getName() + "==>" + i);
}
}
// 1.创建一个线程任务类实现Runnable接口。
class MyRunnable implements Runnable{
// 2.重写run()方法
@Override
public void run(){
for(int i = 0;i < 50;i ++)
System.out.println(Thread.currentThread().getName() + "==>" + i);
}
}
方式二的匿名内部类写法
//3.创建线程任务对象 不是线程对象 仅负责执行线程任务
Runnable target = new Runnable(){ //使用匿名内部类写法
@Override
public void run(){
for(int i = 0;i < 50;i ++)
System.out.println(Thread.currentThread().getName() + "==>" + i);
}
};
创建方式三
多线程是很有用的，我们在进程中创建线程的方式有三种:
（1）直接定义一个类继承线程类Thread，重写run()方法，创建线程对象
调用线程对象的start()方法启动线程。
（2）定义一个线程任务类实现Runnable接口，重写run()方法，创建线程任务对象，把
线程任务对象包装成线程对象， 调用线程对象的start()方法启动线程。
（3）实现Callable接口（拓展）。线程的创建方式三: 实现Callable接口。
– 1,定义一个线程任务类实现Callable接口 ， 申明线程执行的结果类型。
– 2,重写线程任务类的call方法，这个方法可以直接返回执行的结果。
– 3,创建一个Callable的线程任务对象。
– 4,把Callable的线程任务对象包装成一个未来任务对象。
– 5.把未来任务对象包装成线程对象。
– 6.调用线程的start()方法启动线程优缺点：
优点：全是优点。
– 线程任务类只是实现了Callable接口，可以继续继承其他类，而且可以继续实现其他接口（避免了单继承的局限性）
– 同一个线程任务对象可以被包装成多个线程对象
– 适合多个多个线程去共享同一个资源（后面内容）
– 实现解耦操作，线程任务代码可以被多个线程共享，线程任务代码和线程独立。
– 线程池可以放入实现Runable或Callable线程任务对象。(后面了解)
– 能直接得到线程执行的结果！
缺点：编码复杂。
public class ThreadDemo {
public static void main(String[] args) {
// 3.创建一个Callable的线程任务对象
Callable call = new MyCallable();
// 4.把Callable任务对象包装成一个未来任务对象
// -- public FutureTask(Callable callable)
// 未来任务对象是啥，有啥用？
// -- 未来任务对象其实就是一个Runnable对象:这样就可以被包装成线程对象！
// -- 未来任务对象可以在线程执行完毕之后去得到线程执行的结果。
FutureTask<String> task = new FutureTask<>(call);
// 5.把未来任务对象包装成线程对象
Thread t = new Thread(task);
// 6.启动线程对象
t.start();
for(int i = 1 ; i <= 10 ; i++ ){
System.out.println(Thread.currentThread().getName()+" => " + i);
}
// 在最后去获取线程执行的结果,如果线程没有结果，让出CPU等线程执行完再来取结果
try {
String rs = task.get(); // 获取call方法返回的结果（正常/异常结果）
System.out.println(rs);
} catch (Exception e) {
e.printStackTrace();
}
}
}
// 1.创建一个线程任务类实现Callable接口，申明线程返回的结果类型
class MyCallable implements Callable<String>{
// 2.重写线程任务类的call方法！
@Override
public String call() throws Exception {
// 需求：计算1-10的和返回
int sum = 0 ;
for(int i = 1 ; i <= 10 ; i++ ){
System.out.println(Thread.currentThread().getName()+" => " + i);
sum+=i;
}
return Thread.currentThread().getName()+"执行的结果是："+sum;
}
}
线程安全
线程安全问题：多个线程同时操作同一个共享资源的时候可能会出现线程安全问题。
模拟出取款问题的案例：
注意：用高度面向对象的思想设计。
分析：
（1）提供一个账户类Account.java作为创建共享资源账户对象的类。
（2）定义一个线程类来用于创建2个线程分别代表小明和小红来取钱。
小结：
多个线程同时操作同一个共享资源的时候可能会出现线程安全问题。
举例：
线程类
//定义线程类创建两个线程分别代表两个人来取钱
public class DrawThread implements Runnable {
private Account Share_acc;
public DrawThread(Account Share_acc){
this.Share_acc = Share_acc;
}
@Override
public void run(){
//小明、小红都来取100000
Share_acc.drawMoney(100000);
}
}
账户类
//账户类--作为创建共享资源账户对象的类
public class Account {
private String cardID;
private double money;
public Account() {
}
public Account(String cardID, double money) {
this.cardID = cardID;
this.money = money;
}
/**
* 获取
* @return cardID
*/
public String getCardID() {
return cardID;
}
/**
* 设置
* @param cardID
*/
public void setCardID(String cardID) {
this.cardID = cardID;
}
/**
* 获取
* @return money
*/
public double getMoney() {
return money;
}
/**
* 设置
* @param money
*/
public void setMoney(double money) {
this.money = money;
}
public String toString() {
return "Account{cardID = " + cardID + ", money = " + money + "}";
}
public void drawMoney(double money) {
/**开始判断取钱逻辑*/
//1.谁来取钱
String name = Thread.currentThread().getName();
//2.判断余额是否足够
if(this.money >= money)
{
System.out.println(name + "来取钱,余额充足！取出" + money);
//3.更新余额
this.money -= money;
System.out.println(name + "取出钱后,剩余" + this.money);
}else System.out.println(name + "来取钱,余额不足！");
}
}
主函数
public class ThreadSafe {
public static void main(String[] args){
//创建共享资源账户对象
//创建两个线程对象去账户对象中取钱
Account Share_acc = new Account("ICBC-01",100000);
Runnable Little_Ming = new DrawThread(Share_acc);
Thread Ming = new Thread(Little_Ming,"LittleMing");
Ming.start();
Runnable Little_Hong = new DrawThread(Share_acc);
Thread Hong = new Thread(Little_Hong,"LittleHong");
Hong.start();
/*Thread Little_Ming = new Thread( Share_acc,"LittleMing");
Little_Ming.start();
Thread Little_Hong = new Thread( Share_acc,"LittleHong");
Little_Hong.start();*/
}
}
由上可知,两个账户同时取共享账户的100000块钱,会发生冲突！！！账户就不安全了。
线程同步
线程同步的作用：就是为了解决线程安全问题的方案。
线程同步解决线程安全问题的核心思想：
让多个线程实现先后依次访问共享资源，这样就解决了安全问题。线程同步的做法：加锁
是把共享资源进行上锁，每次只能一个线程进入访问完毕以后，其他线程才能进来。线程同步的方式有三种：
（1）同步代码块。
（2）同步方法。
（3）lock显示锁。同步代码块。
作用：把出现线程安全问题的核心代码给上锁，每次只能一个线程进入
执行完毕以后自动解锁，其他线程才可以进来执行。格式：
synchronized(锁对象){
// 访问共享资源的核心代码
}锁对象：理论上可以是任意的“唯一”对象即可。
原则上：锁对象建议使用共享资源。
– 在实例方法中建议用this作为锁对象。此时this正好是共享资源！必须代码高度面向对象
– 在静态方法中建议用类名.class字节码作为锁对象。
同步代码块
代码如下：
public void drawMoney(double money) {
/**开始判断取钱逻辑*/
//1.谁来取钱
String name = Thread.currentThread().getName();
//2.判断余额是否足够 synchronized上锁
synchronized("Lock"){
if(this.money >= money)
{
System.out.println(name + "来取钱,余额充足！取出" + money);
//3.更新余额
this.money -= money;
System.out.println(name + "取出钱后,剩余" + this.money);
}else System.out.println(name + "来取钱,余额不足！");
}
}
将取钱代码块上锁即可！！！
运行结果：
LittleMing来取钱,余额充足！取出100000.0
LittleMing取出钱后,剩余0.0
LittleHong来取钱,余额不足！
在synchronized代码块中,synchronized就像是一个门,只允许一个线程通过,多个线程要排队！
同步方法
同步方法
- 作用：把出现线程安全问题的核心方法给锁起来，
每次只能一个线程进入访问，其他线程必须在方法外面等待。- 用法：直接给方法加上一个修饰符 synchronized.
- 原理: 同步方法的原理和同步代码块的底层原理其实是完全一样的，只是
同步方法是把整个方法的代码都锁起来的。
同步方法其实底层也是有锁对象的：
如果方法是实例方法：同步方法默认用this作为的锁对象。
如果方法是静态方法：同步方法默认用类名.class作为的锁对象。
//直接将方法锁起来
public synchronized void drawMoney(double money) {
/**开始判断取钱逻辑*/
//1.谁来取钱
String name = Thread.currentThread().getName();
//2.判断余额是否足够 synchronized上锁
if(this.money >= money)
{
System.out.println(name + "来取钱,余额充足！取出" + money);
//3.更新余额
this.money -= money;
System.out.println(name + "取出钱后,剩余" + this.money);
}else System.out.println(name + "来取钱,余额不足！");
}
Lock锁
lock显示锁。
java.util.concurrent.locks.Lock机制提供了比synchronized代码块和synchronized方法更广泛的锁定操作,同步代码块/同步方法具有的功能Lock都有,除此之外更强大
Lock锁也称同步锁，加锁与释放锁方法化了，如下：
-public void lock():加同步锁。
-public void unlock():释放同步锁。总结：
线程安全，性能差。
线程不安全性能好。假如开发中不会存在多线程安全问题，建议使用线程不安全的设计类。
public class Account {
private String cardID;
private double money;
//创建锁对象：账户对象对于小明小红唯一,所以锁对象对于小明小红也唯一
private final Lock lock = new ReentrantLock();
public void drawMoney(double money) {
/**开始判断取钱逻辑*/
//1.谁来取钱
String name = Thread.currentThread().getName();
//2.判断余额是否足够
lock.lock();//上锁
try{
if(this.money >= money)
{
System.out.println(name + "来取钱,余额充足！取出" + money);
//3.更新余额
this.money -= money;
System.out.println(name + "取出钱后,剩余" + this.money);
}else System.out.println(name + "来取钱,余额不足！");
}catch (Exception e){
e.printStackTrace();
}finally {
lock.unlock(); //解锁
}
}
}
万一某个用户取钱出现异常,不加异常判断的话会被永远上锁，不严谨！
总结：
线程安全，性能差。
线程不安全性能好。假如开发中不会存在多线程安全问题，建议使用线程不安全的设计类。