购物网站如何做推广,淘宝网站建设教程视频教程,网站建设动漫,机械加工网纹标准目录 多线程
线程
实现线程的方法
方法一:继承Thread父类
方法二:实现Runnable接口
方法三:Callable接口和FutureTask类来实现
Thread方法
线程安全
线程同步
同步代码块
同步方法
Lock锁
线程池
线程池对象的创建方式一:
线程池处理Runnable任务
线程池处理Cal…目录 多线程
线程
实现线程的方法
方法一:继承Thread父类
方法二:实现Runnable接口
方法三:Callable接口和FutureTask类来实现
Thread方法
线程安全
线程同步
同步代码块
同步方法
Lock锁
线程池
线程池对象的创建方式一:
线程池处理Runnable任务
线程池处理Callable任务
并发和并行
并发的含义
并行的理解
线程的六种状态 多线程
线程
线程(Thread是一个程序内部单独一条执行流程),程序中如果只有一条执行流程,那这个程序就是单线程的程序
实现线程的方法
方法一:继承Thread父类
我们先写一个MyThread类,表示我们创建的子线程类
public class MyThread extends Thread{Overridepublic void run(){for (int i 0; i 5; i) {System.out.println(子线程MyThread输出i);}}
}
我们实现main方法
public class main_Thread {public static void main(String[] args) {Thread t new MyThread();t.start();for (int i 0; i 5; i) {System.out.println(主线程main输出:i);}}
}
输出结果为 说明我们现在有两个线程,每一个线程都先运行
需要我们注意的是:
第一点: 我们在子类中重写了run方法,但是我们在调用创建的线程对象t的方法是start(),如果是run()方法会变成单线程,会先执行完run方法里的才会执行main函数中的
第二点: 我们的子线程要放到主线程的前面
缺点:一个子类只能继承一个父类,不能再继承其他类,所以继承了Thread之后,不能继承其他类,会导致功能减少
方法二:实现Runnable接口
(1)定义一个线程任务类MyRunnable实现Runnable接口,重写run()方法
public class MyRunnable implements Runnable{Overridepublic void run(){for (int i 0; i 5; i) {System.out.println(子线程1----i);}}
}
(2)创建MyRunnable任务对象
Runnable r new MyRunnable();
(3)把MyRunnable任务对象交给Thread处理并且调用对象的start()方法启动线程 new Thread(r).start();
下面是mian方法的完整代码
public class main_Thread {public static void main(String[] args) {// 创建MyRunnable任务对象Runnable r new MyRunnable();new Thread(r).start();for (int i 0; i 5; i) {System.out.println(mian线程---i);}}
}
代码优化
不创建子类,用匿名内部类
public class main_Thread {public static void main(String[] args) {// 创建MyRunnable任务对象new Thread(new Runnable() {Overridepublic void run() {for (int i 0; i 5; i) {System.out.println(子线程---i);}}}).start();for (int i 0; i 5; i) {System.out.println(mian线程---i);}}
}优点: 任务类只能实现接口,可以继续继承其他类,实现其他接口
缺点: 需要多一个Runable对象
方法三:Callable接口和FutureTask类来实现
使用原因:因为我们上面两个方法都是调用start方法,进而让调用run方法的,而run方法是void类型的,不会给我们返回值,这时候就要用到方法三
最大优点:可以返回线程执行完毕后的结果
创建线程的步骤:
1.创建任务对象:
(1)定义一个类实现Callable接口,重写call方法,封装要做的事情,和返回的数据
import java.util.concurrent.Callable;public class MyCall implements CallableString {private int n ;public MyCall(int n) {this.n n;}Overridepublic String call() throws Exception {// 描述线程的任务,返回线程执行返回后的结果// 需求:求1-n的和返回int sum 0;for (int i1;in;i){sumi;}return sum;}
}
(2)把Callable类型的对象封装成FutureTask(线程任务对象)
//创建一个Callable对象CallableString call new MyCall(100);
2.把线程任务对象交给Thread对象
// 把Callable的对象封装成一个FutureTask对象// 未来任务对象的作用?// 1.是一个任务对象,实现Runnable对象// 2.可以在线程执行完毕后,// 用未来线程对象调用get方法获取线程执行完毕后值FutureTaskString f1 new FutureTask(call);
3.调用Thread对象的start方法启动线程
// 把任务对象交给一个Thread对象new Thread(f1).start();
4.线程执行完毕后,通过FutureTask对象的get()方法去获取线程任务执行的结果
// 获取线程执行完毕后返回的结果// 注意: 如果执行到这,假如说线程还没有执行完毕// 这里的代码会暂停,等待上面线程执行完毕后才会获取结果String s f1.get();System.out.println(s);
mian主线程中的完整代码 import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;public class main_Thread {public static void main(String[] args) throws Exception {//创建一个Callable对象CallableString call new MyCall(100);// 把Callable的对象封装成一个FutureTask对象// 未来任务对象的作用?// 1.是一个任务对象,实现Runnable对象// 2.可以在线程执行完毕后,// 用未来线程对象调用get方法获取线程执行完毕后值FutureTaskString f1 new FutureTask(call);// 把任务对象交给一个Thread对象new Thread(f1).start();// 获取线程执行完毕后返回的结果// 注意: 如果执行到这,假如说线程还没有执行完毕// 这里的代码会暂停,等待上面线程执行完毕后才会获取结果String s f1.get();System.out.println(s);}
}
Thread方法 public class main_Thread {public static void main(String[] args) throws Exception {Thread t1 new MyThread();t1.setName(1号线程);t1.start();System.out.println(t1.getName()); // 输出线程1的名字Thread t2 new MyThread();t2.setName(2号线程);t2.start();System.out.println(t2.getName()); // 输出线程2的名字// 主线程对象的名字Thread m Thread.currentThread(); // 拿到当前执行线程名字m.setName(nb线程);System.out.println(m.getName()); // mainfor (int i 0; i 5; i) {System.out.println(main主线程输出:i);}}
}
public class ThreadTest {public static void main(String[] args) throws InterruptedException {for (int i 0; i 5 ; i) {if(i 3){// 让当前的线程停止5秒Thread.sleep(5000);}}// join方法让调用方法的线程先执行完Thread t1 new Thread();t1.start();t1.join();}
}
线程安全
线程安全问题的原因: 多个线程,同时访问同一个共享资源,且存在修改资源
我们来模拟线程安全,假如说现在取钱,小明和小红在同一个账户下取钱,现在账户有10万元,小明在他的手机上取10万元,小红在她的手机取10万元,想有没有一种可能小明的手机判断有钱但是还没有取钱的同时,小红的手机也判断有钱,也要完成取钱操作,这样的话小明取出来了10万元,小红手机也取出了10万元,而账户中只有10万元,这就是线程安全
我们用代码模拟一下这个情况
我们先创建账户类,用来创建账户对象
package surf_Thread;public class Account {private String Id;private int money;public Account() {}public Account(String id, int money) {Id id;this.money money;}public String getId() {return Id;}public void setId(String id) {Id id;}public int getMoney() {return money;}public void setMoney(int money) {this.money money;}public void drawMoney(int i) {// 先搞清楚谁来取钱?String name Thread.currentThread().getName();// 判断余额是否足够if(this.moneyi){System.out.println(name来取钱money成功);this.money-i;System.out.println(name来取钱后,余额剩余: money);}else{System.out.println(name 来取钱,余额不足);}}
}
我们在上面创建了一个类的取钱方法,因为每个线程都要进入这个方法,我们可以拿到这个线程的名字
下面我们创建一个线程类,run里面要把握住,这个线程的行为,因为我们要完成取钱,所以必须有一个账户对象,我们要构建一个有参构造器,来接收对那个账户进行操作,还要接受线程的名字
package surf_Thread;public class DrawMoney extends Thread{private Account acc;public DrawMoney(Account acc,String name){super(name); // super 要放到上面this.acc acc;}Overridepublic void run(){//run里面主要实现线程要完成什么事情acc.drawMoney(100000);}
}
主线程
package surf_Thread;public class ThreadTest {public static void main(String[] args) {// 1. 创建一个账户,两个人共同的对象Account acc new Account(ICBC-120,100000);// 2.创建取钱线程new DrawMoney(acc,小明).start();new DrawMoney(acc,小红).start();}
}我们对这个案例运行时,发现: 这个就会造成线程安全问题
我们应该怎么解决呢?
看下面
线程同步
同步代码块 建议使用共享资源作为锁对象,对于实例方法建议使用this作为锁对象
对于静态方法建议使用字节码(类名.class)对象作为锁对象 同步方法 有隐含this
Lock锁 线程池
JDK 5.0起提供了代表线程池的接口: ExecutorService
但是利用接口我们是不能创建线程池对象的,那我们如何得到线程池对象?
线程池对象的创建方式一:
使用ExecutorService的实现类ThreadPoolExecutor自创建一个线程池对象 需要我们注意的是:
1.临时线程什么时候创建?
新任务提交时发现核心线程都在忙,任务队列也满了,并且还可以创建临时线程,此时才会创建临时线程
2.什么时候会开始拒绝新任务?
核心线程和临时线程都在忙,任务队列也满了,新的任务过来的时候才会开始拒绝任务
下面是创建线程池
import java.util.concurrent.*;public class Pool {public static void main(String[] args) {ExecutorService Pool new ThreadPoolExecutor(3,5,8, TimeUnit.SECONDS,new ArrayBlockingQueue(4), Executors.defaultThreadFactory(),new ThreadPoolExecutor.AbortPolicy());}
}
线程池处理Runnable任务
下面是4中不同形式的任务拒绝策略 public class Pool {public static void main(String[] args) {ExecutorService Pool new ThreadPoolExecutor(3,5,8, TimeUnit.SECONDS,new ArrayBlockingQueue(4), Executors.defaultThreadFactory(),new ThreadPoolExecutor.AbortPolicy());Runnable target new MyRunnable();Pool.execute(target); // 线程池自动创建一个新线程,自动处理这个任务,自动执行Pool.execute(target); // 线程池自动创建一个新线程,自动处理这个任务,自动执行Pool.execute(target); // 线程池自动创建一个新线程,自动处理这个任务,自动执行Pool.execute(target); // 复用上面的线程Pool.execute(target); // 复用上面的线程 // 注意临时线程的创建条件:核心线程都占用了,而且队列中都占满了// 如果想要创建临时线程,让上面的线程都被占用,而且队列占满//假如说现在满足条件,那么下面添加任务就开始创建临时线程Pool.execute(target);Pool.execute(target); // 上面创建了两个临时线程// 如果再有任务那么就直接拒绝}
}
因为线程池创建之后开始运行,他不能自动关闭,我们一般情况下也不希望它关闭
那么怎么让他关闭呢?
两种方法: 线程池处理Callable任务
package ThreadPoolTest;import java.util.concurrent.*;public class Pool {public static void main(String[] args) throws Exception {ExecutorService Pool new ThreadPoolExecutor(3,5,8, TimeUnit.SECONDS,new ArrayBlockingQueue(4), Executors.defaultThreadFactory(),new ThreadPoolExecutor.AbortPolicy());FutureString f1 Pool.submit(new MyCall(100));FutureString f2 Pool.submit(new MyCall(200));FutureString f3 Pool.submit(new MyCall(300));String s1 f1.get();}
}
并发和并行
进程: 正在运行的程序(软件)就是独立的进程
线程是属于进程的,一个进程中可以同时运行很多个线程
进程中的多个线程其实是并发和并行的
并发的含义
进程中的线程是由CPU负责执行的,但CPU能同时处理的线程数量有限,为保证全部线程都能往前执行,CPU会轮询为系统的每个线程服务,由于CPU切换的速度很快,给我们的感觉这些线程在同时执行,这就是并发
并行的理解
在同一个时刻上,同时有多个线程在被CPU调度执行
线程的六种状态
