Java中多线程

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();