多线程概念
并行和并发
1.并行:多个指令多核CPU上同时执行
2.并发:同一个CPU核心,交替执行多条指令
进程和线程
1.进程:正在执行的程序
2.线程:线程是进程中的一个执行单元(路径),如果一个进程中包含多个线程,这个程序就是多线程程序。
QQ、迅雷、360、飞秋等
创建线程的方式
线程的实现方式1
Java的API提供了一个Thread类表示线程,创建一个Thread及其子类对象,即是线程对象。
1.写一个Thread的子类
2.复写run方法,写线程的执行代码
3.创建子类对象
4.调用start()方法,开启线程
//1.写一个Thread的子类
public class DownloadThread extends Thread{
//2.复写run方法. run方法中的代码就是线程的执行代码
@Override
public void run() {
for (int i = 0; i <=100; i++) {
//获取线程的名称
String name = getName();
System.out.println(name+"....正在下载..."+i+"%");
}
}
}
public class Demo1 {
public static void main(String[] args) {
//创建线程对象
DownloadThread dt=new DownloadThread();
//开启线程
dt.start();
//创建线程对象
DownloadThread dt1=new DownloadThread();
//开启线程
dt1.start();
}
}
线程的实现方式2
1.写一个Runnable接口的子类
2.复写run方法,编写线程的执行代码
3.创建Thread对象,把Runnable接口的子类对象作为参数传递
4.调用start()方法,开启线程
//线程的执行任务
public class DownloadRunnable implements Runnable{
//run方法中的代码就是线程的执行代码
@Override
public void run() {
for (int i = 0; i <=100; i++) {
//获取当前正在执行的线程
Thread thread = Thread.currentThread();
//再通过线程来获取名称
String name = thread.getName();
System.out.println(name+"....正在下载..."+i+"%");
}
}
}
public class Demo2 {
public static void main(String[] args) {
//线程任务的对象
DownloadRunnable dr = new DownloadRunnable();
//创建线程对象,指定任务
Thread t1 = new Thread(dr);
t1.start();
//创建线程对象,指定任务
Thread t2 = new Thread(dr);
t2.start();
}
}
线程的实现方式3
1.写一个Callable接口的实现类
2.复写call方法。有返回值
3.创建Callable的实现类对象
4.创建FutureTask对象,把Callable的子类对象作为参数传递
5.创建Thread对象,把FuTureTask对象作为参数传递
6.调用start方法,开启线程
注意:如果想的到线程的执行结果,在start方法调用之后,调用FuTureTask对象的get方法
public class MyCallable implements Callable<Integer> {
@Override
public Integer call() throws Exception {
//求1~100的和
int sum=0;
for (int i = 1; i <= 100; i++) {
sum+=i;
}
return sum;
}
}
public class Demo3 {
public static void main(String[] args) throws ExecutionException, InterruptedException {
//3.创建Callable的子类对象
MyCallable mc=new MyCallable();
//4.创建FutureTask对象,把Callable的子类对象作为参数传递
FutureTask<Integer> ft=new FutureTask<>(mc);
//5.创建Thread对象,把FuTureTask对象作为参数传递
Thread t=new Thread(ft);
//6.调用start方法,开启线程
t.start();
//注意:如果想的到线程的执行结果,在start方法调用之后,调用FuTureTask对象的get方法
Integer result = ft.get();
System.out.println(result);
}
}
三种实现方式的对比
1.继承Thread方式:继承Thread类之后不能再继承其他类
2.实现Runnable接口:扩展性较强,可以继承其他类,同时还可以实现多个接口
3.实现Callable接口:线程执行完之后有返回结果
Thread类的方法
public void setName(String name)
设置线程的名称
public String getName()
获取线程的名称
public static Thread currentThread()
获取当前正在执行的线程对象
public static void sleep(long time)
让线程休眠指定的毫秒值。
public void setPriority(int newPriority)
更改线程的优先级。优先级越高,执行到的几率越大
范围:[1,10]
public int getPriority()
获取线程的优先级。
public void setDaemon(boolean flag)
设置线程为守护线程
当主线程停止运行,守护线程也会跟着停止运行。
线程安全问题
多个线程在访问共享数据时,由于CPU的随机性,一个线程还没有执行完,执行权被其他线程抢走了,这个时候就有可能出现线程安全问题。
同步代码块
//锁对象:可以是任意对象,但是要保证唯一
synchronized(锁对象){
//多个线程访问共享数据的代码
}
public class TicketRunnable implements Runnable {
int ticket = 100;
//Object obj=new Object();
@Override
public void run() {
while (true) {
//锁对象:可以是任意对象,要保证是唯一的
synchronized (TicketRunnable.class) {
if (ticket > 0) {
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
//获取线程名称
String name = Thread.currentThread().getName();
System.out.println(name + "...正在卖第" + ticket + "号票");
ticket--;
} else {
break;
}
}
}
}
}
public class Demo4 {
public static void main(String[] args) {
TicketRunnable tr=new TicketRunnable();
//创建两个线程,并执行
new Thread(tr,"窗口A").start();
new Thread(tr,"窗口B").start();
}
}
同步方法
//同步方法:一个线程执行这个方法,另一个线程就必须等待
//同步方法的锁对象:this
public synchronized void method() {
if (ticket > 0) {
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
//获取线程名称
String name = Thread.currentThread().getName();
System.out.println(name + "...正在卖第" + ticket + "号票");
ticket--;
}
}
Lock锁
ReentrantLock lock = new ReentrantLock();
//上锁
lock.lock(); //一个线程执行到这里,其他线程就必须在这里等
//有可能产生安全问题的代码
//解锁
lock.unlock(); //等这个线程执行完了,其他线程才能进来执行
改造上面的同步代码块
public class TicketRunnable implements Runnable {
int ticket = 100;
//创建锁对象
ReentrantLock lock = new ReentrantLock();
@Override
public void run() {
while (true) {
lock.lock(); //上锁
try {
//锁对象:可以是任意对象,是唯一的
if (ticket > 0) {
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
//获取线程名称
String name = Thread.currentThread().getName();
System.out.println(name + "...正在卖第" + ticket + "号票");
ticket--;
}
} catch (Exception e) {
e.printStackTrace();
} finally {
//不管前面有没有异常发生,锁都得关闭。
lock.unlock();
}
}
}
}
生产者消费者案例
自己实现等待和唤醒
由于CPU的随机性,多个线程在执行的时候是在相互抢夺CPU的执行权。为了让多个线程协同工作,可使用等待和唤醒机制。
消费者和生产者案例就是一个很经典的,利用等待和唤醒,让多个线程达到协同工作的效果。满足的是一种供需关系。
//桌子
public class Desk {
//默认生产10个汉堡包
private int count = 10;
//当前桌子的状态 true有 false:没有
private boolean flag;
//锁对象,final的作用是让锁对象时唯一的,不能更改
private final Object lock = new Object();
public int getCount() {
return count;
}
public void setCount(int count) {
this.count = count;
}
public boolean isFlag() {
return flag;
}
public void setFlag(boolean flag) {
this.flag = flag;
}
public Object getLock() {
return lock;
}
}
生产者
//生产者(厨师)
public class Cooker implements Runnable {
public Desk desk; //桌子
//通过构造方法,给desk变量赋值
public Cooker(Desk desk) {
this.desk = desk;
}
@Override
public void run() {
while (true) {
//同步代码块
synchronized (desk.getLock()) {
if (desk.getCount() == 0) {
break;
} else {
//判断桌子上有没有汉堡包
if (desk.isFlag()) { //有
//如果有,厨师线程就等待
try {
//wait()方法,释放锁再等待
desk.getLock().wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
} else { //没有
System.out.println("生产一个汉堡包");
desk.setCount(desk.getCount() - 1);
//把状态改为true
desk.setFlag(true);
//把消费者线程唤醒
desk.getLock().notifyAll();
}
}
}
}
}
}
消费者
//消费者(吃货)
public class Fooder implements Runnable{
private Desk desk;
public Fooder(Desk desk) {
this.desk = desk;
}
@Override
public void run() {
while (true){
synchronized (desk.getLock()){
if(desk.getCount()==0){
break;
}else {
//判断有没有汉堡包
if(desk.isFlag()){ //有
System.out.println("吃货吃了一个包子");
desk.setFlag(false);
desk.getLock().notifyAll(); //把生产者唤醒
}else { //没有
try {
desk.getLock().wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
}
}
}
测试类
public class Demo2 {
public static void main(String[] args) {
Desk desk=new Desk();
//创建两个线程对象
Cooker cooker = new Cooker(desk); //生产者任务
Fooder fooder = new Fooder(desk); //消费者任务
new Thread(cooker).start();
new Thread(fooder).start();
}
}
使用阻塞队列实现
Java的API给开发者提供了一种集合叫做阻塞队列,如图所示。它是以队列结构来进行存取元素的,类似于生活中的排队。当放满了就不能再放了,当取没了也就不能再取了。
生产者
//厨师
public class Cooker implements Runnable{
//阻塞队列
private ArrayBlockingQueue<String> list;
public Cooker(ArrayBlockingQueue<String> list) {
this.list = list;
}
@Override
public void run() {
while (true){
//不断的往阻塞队列中放
try {
list.put("汉堡包");
System.out.println("生产一个汉堡包");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
消费者
//吃货
public class Fooder implements Runnable {
//阻塞队列
private ArrayBlockingQueue<String> list;
public Fooder(ArrayBlockingQueue<String> list) {
this.list = list;
}
@Override
public void run() {
while (true) {
try {
String take = list.take();
System.out.println("取出一个" + take);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
测试类
public class Demo3 {
public static void main(String[] args) {
//创建阻塞队列
ArrayBlockingQueue<String> list = new ArrayBlockingQueue<>(1);
//创建生产者任务
Cooker cooker = new Cooker(list);
//创建消费者任务
Fooder fooder = new Fooder(list);
//创建两个线程
new Thread(cooker).start();
new Thread(fooder).start();
}
}