多线程的创建方式一:extends Thread
package com.xt;
/**
* 多线程的创建,方式1:继承于Thread类的方式
* 1.创建一个继承于Thread类的子类
* 2.子类重写Thread类中的run() -->将此线程执行的操作声明在run()中
* 3.创建Thread类的子类的对象
* 4.通过该对象调用Thread类的start()
*
* 例子:遍历100以内的所有的偶数
*
* @author tyl
* @creat 2022-03-26-9:36
*/
//1.创建一个继承于Thread类的子类
class MyThread extends Thread{
//2.子类重写Thread类中的run()
@Override
public void run() {
for (int i = 0; i < 100; i++) {
if (i%2==0){
System.out.println(Thread.currentThread().getName()+i);
}
}
}
}
public class ThreadTest {
public static void main(String[] args) {
//3.创建Thread类的子类的对象
MyThread mt=new MyThread();
//4.通过该对象调用Thread类的start()
//start()作用:①启动该线程 ②调用当前线程的run()
mt.start();
//问题1:不能通过直接调用对象.run()的方式启动线程
//mt.run();
//问题2:再启动一个线程,遍历100以内的偶数,不可以让已经start()的线程去执行,会报 IllegalThreadStateException 异常
// mt.start();
MyThread mt2=new MyThread();
mt2.start();
//如下操作依然在main线程中执行
for (int i = 0; i < 100; i++) {
if (i%2==0){
System.out.println(Thread.currentThread().getName()+i+"*****************");
}
}
}
}
多线程的创建方式二:implements Runnable方式
package com.xt;
/**
* 每个线程拥有自己独立的栈和程序计数器
* 多个线程共享一个进程中的结构:堆、方法区
*
* 进程作为资源分配的单位,有生命周期
* 线程作为执行和调度的基本单位,每个线程拥有独立的运行栈和程序计数器
* 线程是一个程序的一条执行路径
*
* 单核CPU与多核CPU:
* 单核CPU是假的多线程,因为在同一个时间内,也只能执行一个线程的任务。多核CPU才能更好地发挥多线程的效率。
* 一个java应用程序java.exe,其实是一个多线程:main()主线程、gc()垃圾回收线程、异常处理线程。如果发生异常会影响主线程。
*
* 并行:多个CPU同时执行多个任务
* 并发:一个CPU(时间片)同时执行多个任务
*
* 创建多线程的方式二:实现Runnable接口
* 1.创建了实现Runnable接口的类
* 2.实现类去实现Runnable中的抽象方法:run()
* 3.创建实现类的对象
* 4.将此对象作为参数传递到Thread类的构造器中,创建Thread类的对象
* 5.通过Thread类的对象调用start()
*
* 比较创建线程的两种方式:
* 开发中:优先选择Runnable接口的方式
* 原因:1、实现方式没有类的单继承性的局限性
* 2、实现方式更适合处理多个线程有共享数据的情况
* 联系:1、public class Thread implements Runnable
* 相同点: 两种方式都需要重写run(),将线程要执行的逻辑声明在run()中。
* 目前这两种方式,要想启动线程,都是调用Thread类中的start()。
*
* 线程通信:wait()/notify()/notifyAll(),此3种方法定义在Object类中
*
* 线程的分类:
* 守护线程、用户线程
*
* @author tyl
* @creat 2022-03-26-19:48
*/
//1.创建了实现Runnable接口的类
class MyThread1 implements Runnable{
//2.实现类去实现Runnable中的抽象方法:run()
@Override
public void run() {
for (int i = 0; i < 100; i++) {
if (i%2==0){
System.out.println(Thread.currentThread().getName()+i);
}
}
}
}
public class ThreadTest1 {
public static void main(String[] args) {
//3.创建实现类的对象
MyThread1 m1=new MyThread1();
//4.将此对象作为参数传递到Thread类的构造器中,创建Thread类的对象
Thread t1=new Thread(m1);
//5.通过Thread类的对象调用start():①启动线程②调用当前线程的run()-->调用了Runnable类型的target的run()
t1.start();
//new Thread(m1).start();
//再启动一个线程,打印100以内的偶数
Thread t2=new Thread(m1);
t2.start();
}
}
测试类Thread中的常用方法:
package com.xt;
/**
* 测试Thread类中的常用方法
* 1.start() 启动当前线程; 调用当前线程的run()
* 2.run() 通常需要重写,将创建的线程执行的操作声明在此方法中
* 3.currentThread() 返回执行当前代码的线程
* 4.getName() 获取当前线程的名字
* 5.setName() 设置当前线程的名字
* 6.yield() 释放当前CPU的执行权
* 7.join() 在线程a中调用线程b的join(),此时线程a进入阻塞状态,知道线程b完全执行完以后,线程a才结束阻塞状态
* 8.stop() 已过时。当执行此方法时,强制结束当前线程
* 9.sleep(long millitime) 让当前线程“睡眠”指定的millitime毫秒,在该段时间内,线程处于阻塞状态
* 10.isAlive() 判断当前线程是否存活
*
* 线程优先级:
* 1.
* MAX_PRIORITY : 10
* MIM_PRIORITY : 1
* NORM_PRIORITY : 5
* 2.如何获取和设置当前线程优先级:
* getPriority()
* setPriority(int p)
* 说明:高优先级的线程要抢占低优先级线程cpu的执行权,但只是从概率上讲,高优先级线程高概率被cpu执行,并不意味着高优先级的
* 线程执行完之后,低优先级的线程才被执行
*
* @author tyl
* @creat 2022-03-26-10:38
*/
class HelloThread extends Thread{
@Override
public void run() {
for (int i = 0; i < 100; i++) {
if (i % 2 == 0) {
try {
sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() +Thread.currentThread().getPriority()+ ":" + i);
}
// if (i%20==0){
// yield();
// }
}
}
public HelloThread(String name){
super(name);
}
}
public class ThreadMethodTest {
public static void main(String[] args) {
HelloThread t1 = new HelloThread("线程一");
// t1.setName("线程一");
//设置分线程的优先级
t1.setPriority(1);
t1.start();
//给主线程命名
Thread.currentThread().setName("主线程");
for (int i = 0; i < 100; i++) {
if (i % 2 == 0) {
System.out.println(Thread.currentThread().getName() +Thread.currentThread().getPriority()+ ":" + i);
}
if (i==20){
try {
t1.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
System.out.println(t1.isAlive());
System.out.println(Thread.currentThread().isAlive());
}
}
例子:
package com.tyl;
/**
* 练习:创建2个分线程,其中一个遍历100以内的偶数,另一个遍历100以内的奇数
*
* @author tyl
* @creat 2022-03-26-10:19
*/
class OuShu extends Thread{
@Override
public void run() {
for (int i = 0; i < 100; i++) {
if (i%2==0){
System.out.println(Thread.currentThread().getName()+":"+i);
}
}
}
}
class JiShu extends Thread{
@Override
public void run() {
for (int i=0;i<100;i++){
if (i%2!=0){
System.out.println(Thread.currentThread().getName()+":"+i);
}
}
}
}
public class ThreadDemo {
public static void main(String[] args) {
OuShu o=new OuShu();
JiShu j=new JiShu();
o.start();
j.start();
//创建Thread匿名子类的方式(因为对象只用了一次)
new Thread(){
@Override
public void run() {
for (int i=0;i<100;i++){
if (i%2!=0){
System.out.println(Thread.currentThread().getName()+":"+i);
}
}
}
}.start();
new Thread(){
@Override
public void run() {
for (int i=0;i<100;i++){
if (i%2==0){
System.out.println(Thread.currentThread().getName()+":"+i);
}
}
}
}.start();
}
}
package com.tyl;
/**
* 创建3个窗口卖票,总票数为100张 使用继承的方式
* 存在线程安全的问题,待解决
* @author tyl
* @creat 2022-03-26-14:44
*/
class Window extends Thread{
private static int ticket=100;
@Override
public void run() {
while(true){
if (ticket>0){
System.out.println(getName()+": 卖票,票号为:"+ticket);
ticket--;
}else{
break;
}
}
}
}
public class WindowTest {
public static void main(String[] args) {
Window w1=new Window();
Window w2=new Window();
Window w3=new Window();
w1.setName("窗口1");
w2.setName("窗口2");
w3.setName("窗口3");
w1.start();
w2.start();
w3.start();
}
}
package com.tyl;
/**
* 创建3个窗口卖票,总票数为100张 使用实现Runnable接口的方式
* 存在线程安全的问题,待解决
* @author tyl
* @creat 2022-03-26-14:44
*/
class Window1 implements Runnable{
private int ticket=100;
@Override
public void run() {
while(true){
if (ticket>0){
System.out.println(Thread.currentThread().getName()+": 卖票,票号为:"+ticket);
ticket--;
}else{
break;
}
}
}
}
public class WindowTest1 {
public static void main(String[] args) {
Window1 w=new Window1();
Thread t1=new Thread(w);
Thread t2=new Thread(w);
Thread t3=new Thread(w);
t1.setName("窗口1");
t2.setName("窗口2");
t3.setName("窗口3");
t1.start();
t2.start();
t3.start();
}
}