for(int i = 0;i < 50;i++)
{
System.out.println(“新线程正在执行” + i);
}
}
}
在主线程中调用:
public static void main(String[] args)
{
//创建自定义线程对象
myThread mT = new myThread();
//开启新线程,让新的线程执行程序,jvm调用线程中的run
mT.start();
//在main方法中执行
for(int i = 0;i < 50;i++)
{
System.out.println(“main线程正在执行” + i);
}
}
分析:
-
在主线程中创建自定义线程对象,调用star方法开启新线程,让新的线程执行程序,jvm再调用线程中的run方法
-
创建新的线程后,会产生两个执行路径,都会被CPU执行,CPU有自己的选择执行权力,所以会出现随机的执行结果
-
可以理解为两个线程在抢夺CPU的资源(时间)
-
注:线程对象调用 run 方法和调用 star 方法的区别:
(1) 线程对象调用 run 方法不开启线程,仅仅是对象调用方法
(2) 线程对象调用 star 方法开启线程,并让 JVM 调用 run 方法在开启的线程中执行
问题分析:
为什么要继承 Thread 类,并调用 star 方法才能开启线程,为什么不像下面代码一样直接创建 Thread 类的对象呢?
Thread t1 = new Thread();
t1.star();
-
创建线程的目的是为了建立程序单独的执行路径,让多部分代码实现同时执行,而以上代码,直接创建 Thread 类的对象,虽然没有语法错误,不会报错,但该 star 调用的是Thread 类中的 run 方法,而这个方法什么也没做,更重要的是这个 run 方法中并没有定义我们需要让线程执行的代码
-
Thread 类 run 方法中的任务并不是我们所需要的,只有重写这个 run 方法,Thread 类已经定义了线程任务的编写位置(run 方法),那么只要在 run 方法中定义任务代码即可,即重写 run 方法
(2) 多线程内存理解
-
多线程在执行的时候,是在栈内存中的,每一个执行线程都有一片自己的所属栈内存空间,进行方法的压栈和出栈
-
当执行线程的任务结束了,线程自动在栈内存中释放,当所有的执行线程都结束了,进程也就结束了
(3) 获取和设置线程名称
-
String getName():返回该线程的名称(同 Thread.currentThread().getName())
-
Thread.currentThread():获取当前线程对象
-
Thread.currentThread().getName():获取当前线程对象的名称
-
setName():设置线程名称
public static void main(String[] args)
{
myThread mT = new myThread();
mT.start();
mT.setName(“oneStar”); //设置线程名称
//System.out.println(getName()); //使用getName()方法获取线程名称 在新线程中可以这样使用
System.out.println(Thread.currentThread().getName()); //使用Thread.currentThread().getName()获取线程名称
System.out.println(Thread.currentThread()); //获取当前线程对象
}
(4) Thread 类 sleep 方法
sleep 方法是一个静态的方法,可以通过 Thread 类直接调用,会有异常抛出
public static void main(String[] args) {
myThread mT = new myThread();
mT.start();
//使用sleep方法延时打印for循环
for(int i = 0;i < 5;i++)
{
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(i);
}
}
2、实现 Runnable 接口创建线程(方法二)
Runnable 接口用来指定每一个线程要执行的任务,包含了一个 run 的无参数抽象方法,需要由接口实现重写该方法。此创建线程的方法是声明实现 Runnable 接口的类,该类实现 run 方法,然后创建 Runnable 的子类对象,传入到某个线程的构造方法中,开启线程
(1) 创建步骤:
-
定义类实现 Runnable 接口
-
重写接口中的 run 方法
-
创建 Thread 类的方法
-
将 Runnable 接口的子类对象作为参数传递给 Thread 类的构造函数
-
调用 Thread 类的 star 方法开启线程
定义实现类接口
//定义实现类接口
public class myRunnable implements Runnable {
//重写run方法
public void run()
{
for(int i = 0;i < 5;i++)
{
System.out.println(“myRunnable线程正在执行!”);
}
}
}
在主线程中调用
public static void main(String[] args)
{
//创建线程执行目标类对象
myRunnable mR = new myRunnable();
//将Runnable接口的子类对象作为参数传递给Thread类的构造函数
Thread t1 = new Thread(mR);
Thread t2 = new Thread(mR);
//开启线程
t1.start();
t2.start();
for(int i = 0;i < 5;i++)
{
System.out.println(“main线程正在执行!”);
}
}
(2) 实现 Runnable 接口的好处
-
避免了单继承的局限性,所以此方法较为常用
-
将线程分为两部分,一部分线程对象,一部分线程任务,更加符合面向对象思想(继承 Thread 类线程对象和线程任务耦合在一起)
-
将线程任务单独分离出来封装成对象,类型就是 Runnable 接口类型
-
Runnable 接口对线程对象和线程任务进行解耦,降低紧密性或依赖性,创建线程和执行任务不绑定
三、线程的匿名内部类
==========
使用线程的匿名内部类方式,可以方便的实现每个线程执行不同线程任务操作
方法一:重写 Thread 类中的方法创建线程
new Thread() {
public void run() {
for (int x = 0; x < 40; x++) {
System.out.println(Thread.currentThread().getName()
- “…X…” + x);
}
}
}.start();
方法二:使用匿名内部类的方式实现 Runnable 接口,重写 Runnable 接口中的 run 方法
Runnable r = new Runnable() {
public void run() {
for (int x = 0; x < 40; x++) {
System.out.println(Thread.currentThread().getName()
- “…Y…” + x);
}
}
};
new Thread®.start();