【Java寒假打卡】Java基础-多线程
【Java寒假打卡】Java基础-多线程
-
- 概述
- 读线程实现方式-继承Thread
- 多线程实现方式-Callable
- 三种实现方式的对比
- Thread方法
- 守护线程
- 线程的优先级
概述
-
并发和并行
-
进程和线程
读线程实现方式-继承Thread
- 继承Thread类进行实现
package com.hfut.edu.test11;
public class MyThread extends Thread{
// 重写run方法
@Override
public void run() {
super.run();
for (int i = 0; i < 100; i++) {
System.out.println("线程开启了" + i);
}
}
}
package com.hfut.edu.test11;
public class test1 {
public static void main(String[] args) {
MyThread m1 = new MyThread();
m1.start();// 开启一个线程
MyThread m2 = new MyThread();
m2.start();
// 线程交替执行
}
}
run方法与start方法的区别：run方法表示的仅仅是创建对象，使用对象去调用方法，并没有开启线程，使用start方法开启线程
start方法启动线程；然后使用JVM调用此线程的run()方法
- 开启多线程实现方式-runable接口
实现Runable 接口
package com.hfut.edu.test11;
public class MyRunable implements Runnable{
@Override
public void run() {
for (int i = 0; i < 100; i++) {
System.out.println("第二种多线程的实现" + i);
}
}
}
package com.hfut.edu.test11;
public class tewts2 {
public static void main(String[] args) {
// 创建一个参数对象
MyRunable mr = new MyRunable();
// 创建线程对象 将参数传递给这个线程
Thread t1 = new Thread(mr);
t1.start();
MyRunable mr1 = new MyRunable();
Thread t2 = new Thread(mr1);
t2.start();
// 线程交替执行
}
}
多线程实现方式-Callable
package com.hfut.edu.test11;
import java.util.concurrent.Callable;
public class MyCallable implements Callable<String> {
// 实现call 方法
@Override
public String call() throws Exception {
for (int i = 0; i < 100; i++) {
System.out.println("hhhhhhhh" + i);
}
return "xxxx";
}
}
package com.hfut.edu.test11;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
public class Demo {
public static void main(String[] args) throws ExecutionException, InterruptedException {
MyCallable mc = new MyCallable();
FutureTask<String> ft = new FutureTask<>(mc);// 可以获取线程执行完毕之后的结果
Thread t1 = new Thread(ft);
t1.start();
String s = ft.get();// 获取线程执行之后的结果
System.out.println(s);
}
}
三种实现方式的对比
Thread方法
- 获取线程名称
package com.hfut.edu.test11;
public class MyThread extends Thread{
// 重写run方法
@Override
public void run() {
// 获取线程的名称
String name = getName();
System.out.println(name);
}
}
- 获取当前线程
package com.hfut.edu.test11;
public class MyThread extends Thread{
// 重写run方法
@Override
public void run() {
// 获取线程的名称
Thread t = Thread.currentThread();// 静态方法调用
System.out.println(t);
}
}
- 多线程的带参数构造方法
package com.hfut.edu.test11;
public class MyThread extends Thread{
public MyThread(){}
public MyThread(String name){
super(name);// 设置线程的名称
}
// 重写run方法
@Override
public void run() {
// 获取线程的名称
Thread t = Thread.currentThread();// 静态方法调用
System.out.println(t.getName());// 打印线程的名字
}
}
- Sleep方法
package com.hfut.edu.test11;
public class test3 {
public static void main(String[] args) throws InterruptedException {
for (int i = 1; i < 61; i++) {
System.out.println(i);
Thread.sleep(1000);// 程序休眠1s
}
}
}
守护线程
- 当守护线程执行完毕，其他线程也就没有执行下去的必要
package com.hfut.edu.test11;
public class test4 {
public static void main(String[] args) {
MyThread1 m1 = new MyThread1();
MyThread2 m2 = new MyThread2();
m1.setName("主线程");
m2.setName("其他线程");
m1.setDaemon(true);// 主线程执行完毕 其他线程直接结束
m1.start();
m2.start();
}
}
线程的优先级
- 优先级更高 抢到CPU的几率更高
package com.hfut.edu.test11;
public class test4 {
public static void main(String[] args) {
MyThread1 m1 = new MyThread1();
MyThread2 m2 = new MyThread2();
m1.setName("主线程");
m2.setName("其他线程");
m1.setDaemon(true);// 主线程执行完毕 其他线程直接结束
m1.start();
m2.start();
System.out.println(m1.getPriority());// 打印线程的优先级 默认优先级5
System.out.println(m2.getPriority());//
m1.setPriority(6);
m2.setPriority(7);// 设置线程的优先级
}
}