javaSE基础-多线程
多线程
线程是系统进行运算调度的最小单位，也被称为轻量级进程，它包含在进程之中，是进程的实际运作单位。
线程由线程ID、当前指令指针(PC)、寄存器集合和堆栈组成，它不能独立拥有系统资源，但它可与同属一个进程的其它线程共享该进程所拥有的全部资源。
基本概念
程序：为完成特定任务、用某种语言编写的一组指令的集合
进程：是程序的一次执行过程，或是正在运行的一个程序。是一个动态的过程：有它自身的产生、存在和消亡的过程——生命周期
线程：进程可进一步细化为线程，是一个程序内部的一条执行路径
单核CPU和多核CPU：指CPU的核心数，早期CPU大多是单核心，处理多任务多开应用程序能力有限，而后来多核心CPU技术开发，轻松的应对多任务程序的运行，如多开游戏挂载。
并行和并发：并行是多个任务能在同一时刻运行，而并发在处理多任务只能同一时间间隔发生。多核CPU能很好地处理并行+并发同时发生。
多线程优点
- 提高应用程序的响应，对图形界面更凸显，有良好的用户体验
- 提高计算机处理器的利用率
- 改善程序结构，将复杂的进程优化为多个线程，独立运行，有利于理解和维护
多线程应用背景
- 程序需要同时执行两个或多个任务
- 程序需要实现一些等待的任务时，如用户输入、文件读写操作、网络操作、搜索等
- 需要在后台与运行的程序
线程的创建和使用
线程Thread常用的方法
1、start(): 启动当前线程，调用当前线程的run()
2、run(): 通常需要重写Thread类中的此方法，将创建的线程要执行的操作声明在此方法中
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(): 判断当前线程是否存活
线程的创建方式
方式一：继承Thread类
示例一：
//ThreadTest.java
/**
* 多线程的创建：方式一：继承Thread类
* 1、创建一个继承于Thread类的子类
* 2、在这个子类中重写run()方法 --> 在run方法中编写代码主体
* 3、在主线程main()中创建子类的对象
* 4、子类对象调用start()方法
*/
public class ThreadTest {
public static void main(String[] args) {
//3、在主线程main()中创建子类的对象
MyThread t = new MyThread();
//4、子类对象调用start()方法 作用①启动当前的线程; ②调用当前线程的run()
//当前存在 main主线程 + MyThread子线程
t.start();
//问题一：直接子类对象调用run()，只是普通的方法调用，没有启动线程
//t.run();
//问题二：增加线程，需要重新new一个对象，调用start()方法
MyThread t2 = new MyThread();
t2.start();
for (int i = 0; i < 50; i++) {
if (i % 2 == 0) {
System.out.println(i + "********main()********");
}
}
}
}
//1、创建一个继承于Thread类的子类
class MyThread extends Thread {
//2、在这个子类中重写run()方法
@Override
public void run() {
for (int i = 0; i < 50; i++) {
if (i % 2 == 0) {
System.out.println(i);
}
}
}
}
方式二：实现Runnable接口
示例二：
//ThreadTest4.java
/**
* 创建多线程方式二：实现Runnable接口
* 1、创建一个实现了Runnable接口的类
* 2、实现类去实现Runnable中的抽象方法run()
* 3、创建实现类的对象
* 4、将此对象作为参数传给Thread类的构造器中
* 5、通过Thread类的对象调用start()方法
*/
public class ThreadTest4 {
public static void main(String[] args) {
//3、创建实现类的对象
MThread mThread = new MThread();
//4、将此对象作为参数传给Thread类的构造器中
Thread t1 = new Thread(mThread);
t1.setName("线程1");
//5、通过Thread类的对象调用start()方法
t1.start();
Thread t2 = new Thread(mThread);
t2.setName("线程2");
t2.start();
}
}
//1、创建一个实现了Runnable接口的类
class MThread implements Runnable{
//2、实现类去实现Runnable中的抽象方法run()
@Override
public void run() {
for (int i = 0; i < 50; i++) {
if(i % 2==0){
System.out.println(Thread.currentThread().getName() + ":" + i);
}
}
}
}
两种创建线程方式比较：
优先选择，实现Runnable接口的方式
原因：①实现的方式没有类的单继承性的局限性 ②实现的方式更适合用来处理多个线程共享数据的情况
两则的联系：Thread类也实现了 Runnable接口
相同点：两种方式都需要重写run()，将线程要执行的逻辑代码声明在run()方法中
线程的优先级:
1、优先级的参数 MAX_PRIORITY=10， MIN_PRIORITY=1 和 NORM_PRIORITY=5(默认的)
2、获取和设置当前线程的优先级：
-
getPriority():获取线程的优先级
-
setPriority(int p):设置线程的优先级
说明：高优先级的线程要抢占低优先级线程的cpu的执行权。只是从概率上，高优先级的线程高概率被优先执行。
案例：
//WindowsTest2.java
/**
* 使用实现接口Runnable接口方式：三个窗口一起销售100张票
* 问题：线程安全问题，开始都是以100张票计算
*/
public class WindowsTest2 {
public static void main(String[] args) {
Windows2 w = new Windows2();
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();
}
}
class Windows2 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;
}
}
}
}
一般java应用程序包含三个基本的线程：
- main()方法的主线程
- gc()垃圾回收机制的子线程
- 异常处理的子线程
线程分类
-
主线程：程序启动时，操作系统会创建一个进程，与此同时会立即运行一个线程，该线程通常被称为主线程。主线程的作用主要有两个，一个是产生其他子线程，另一个是最后执行各种关闭操作，例如文件的关闭。
-
子线程：程序中创建的其它线程
-
守护线程：如gc垃圾回收线程
-
用户线程：如main()方法执行的主线程
线程的生命周期
线程的五种状态
Thread生命周期如图：
- 新建：当一个Thread类或其子类对象被声明并创建，新生的线程对象处于新建状态
- 就绪：处于新建状态的线程被start()后，将进入线程队列等待cpu时间片，此时它已具备了运行的条件，只是没有分配到cpu资源
- 运行：当就绪的线程被调度并获取cpu资源时，便进入运行状态，run()方法定义了线程操作和功能
- 阻塞：在某种特殊情况下，被人为挂起或执行输入输出操作时，让出cpu并临时中止自己的执行，进入阻塞状态
- 死亡：线程完成了它的全部工作或线程提前被强制性中止或出现异常导致结束
线程的同步
线程同步：即当有一个线程在对内存进行操作时，其他线程都不可以对这个内存地址进行操作，直到该线程完成操作， 其他线程才能对该内存地址进行操作，而其他线程又处于等待状态，实现线程同步的方法有很多，临界区对象就是其中一种。
通过同步机制，解决线程的安全问题，五种方式：
-
synchronized关键字
-
同步代码块
-
同步方法
-
-
重入锁reentrantLock(): 俗称Lock锁 jdk5.0+版本
-
使用局部变量ThreadLocal类
-
使用阻塞队列LinkedBlockingQueue类
-
使用原子变量AtomicInteger类
使用顺序说明：
Lock -> 同步代码块（进入方法体，进行分配相应的资源） -> 同步方法（在方法体外）
方式一：同步代码块
//WindowsTest2.java
/**
* 使用实现接口Runnable接口方式：三个窗口一起销售100张票
* 问题：线程不安全问题，开始都是以100张票计算，出现重票，错票
* 原因：当某个线程操作车票的过程中，尚未操作完成，其它线程也参与进来操作车票
*
* 方式一：同步代码块
* synchronized(同步监听器){
* //需要被同步的代码
* }
* 说明：
* 1、操作共享数据的代码，即为需要被同步的代码
* 2、共享数据：就是多个线程共同操作的变量，比如ticket
* 3、同步监听器：即锁。任何一个类的对象，都可以充当锁 --> 要求：多个线程必须共用同一把锁
* 注意：
* ① 在实现Runnable接口创建多线程的方式中，可以考虑使用this(锁)当作同步监视器
* ② 在继承Thread类创建多线程的方式中，慎用this充当同步监视器，考虑使用当前类作为同步监视器
*/
public class WindowsTest2 {
public static void main(String[] args) {
Windows2 w = new Windows2();
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();
}
}
class Windows2 implements Runnable{
private int ticket = 100;
//Dog dog = new Dog();
@Override
public void run() {
while(true) {
//方式一：此处的this 表示当前run()方法对应的类Windows2的一个对象，恰好new唯一一个对象
synchronized (this) { //方式二：synchronized (dog) {
if (ticket > 0) {
System.out.println(Thread.currentThread().getName() + ": 卖票的票号：" + ticket);
ticket--;
} else {
break;
}
}
}
}
}
方式二：同步方法
总结：
1、同步方法仍然涉及到同步监听器，只是不需要显式的声明
2、非静态的同步方法，同步监听器是：this
静态的同步方法，同步监听器是：当前类本身（类.class）
//WindowsTest3.java
/**
* 使用同步方法：解决实现Runnable接口的多线程安全问题
*/
public class WindowsTest3 {
public static void main(String[] args) {
Windows3 w = new Windows3();
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();
}
}
class Windows3 implements Runnable {
private int ticket = 100;
@Override
public void run() {
while (true) {
show();
}
}
//同步方法
private synchronized void show() {
if (ticket > 0) {
System.out.println(Thread.currentThread().getName() + ": 卖票的票号：" + ticket);
ticket--;
}
}
}
通过继承Thread类实现多线程同步
//WindowsTest4.java
/**
* 使用同步方法：继承的方式
*/
public class WindowsTest4 {
public static void main(String[] args) {
Windows4 p1 = new Windows4();
Windows4 p2 = new Windows4();
Windows4 p3 = new Windows4();
p1.setName("窗口1");
p2.setName("窗口2");
p3.setName("窗口3");
p1.start();
p2.start();
p3.start();
}
}
class Windows4 extends Thread {
private static int ticket = 100;
@Override
public void run() {
while (true) {
show();
}
}
//静态方法：同步监听器是当前类的，类只会加载一次；
// 非静态方法的同步监听器是this，上面new多个类就有多少的线程对象
private static synchronized void show() {
if (ticket > 0) {
System.out.println(Thread.currentThread().getName() + ": 卖票的票号：" + ticket);
ticket--;
}
}
}
案例：
//AccountTest.java
/**
* 有个银行账户：有两个账户分别向同一账户存储了3000，每次1000，存3次，每次存完之后打印账户余额
*/
public class AccountTest {
public static void main(String[] args) {
Account a = new Account(0);
Customer c1 = new Customer(a);
Customer c2 = new Customer(a);
c1.setName("甲");
c2.setName("乙");
c1.start();
c2.start();
}
}
class Account {
private double balance;
public Account(double balance) {
this.balance = balance;
}
//存钱方法
public synchronized void deposit(double amt) {
if (amt > 0) {
balance += amt;
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "：存钱成功，用户余额：" + balance);
}
}
}
class Customer extends Thread {
private Account account;
public Customer(Account account) {
this.account = account;
}
@Override
public void run() {
for (int i = 0; i < 3; i++) {
account.deposit(1000);
}
}
}
方式三：Lock锁
synchronized 与 lock的异同：
相同：二则都可以解决线程安全问题
不同：synchronized机制在执行完相应的同步代码以后，自动的释放同步监视器
Lock需要手动启动同步lock()，同时结束也需要手动实现unlock()
//LockTest.java
/**
* 解决线程安全问题方式三：Lock锁 -->jdk5.0之后支持
*/
public class LockTest {
public static void main(String[] args) {
Windows5 w = new Windows5();
Thread a1 = new Thread(w);
Thread a2 = new Thread(w);
Thread a3 = new Thread(w);
a1.setName("窗口1");
a2.setName("窗口2");
a3.setName("窗口3");
a1.start();
a2.start();
a3.start();
}
}
class Windows5 implements Runnable{
private int ticket = 100;
//1、实例化ReentrantLock
private ReentrantLock lock = new ReentrantLock();
@Override
public void run() {
while(true){
try {
//2、手动添加锁方法：lock()
lock.lock();
if (ticket > 0){
System.out.println(Thread.currentThread().getName() + ": 卖的票号为：" + ticket);
ticket--;
}else {
break;
}
}finally {
//3、手动解锁：unlock()
lock.unlock();
}
}
}
}
单例模式(懒汉式)线程安全
//Bank.java
/**
* 单例模式中懒汉式的线程安全问题：使用同步机制
*/
public class BankTest {
}
class Bank{
private Bank(){}
private static Bank instance = null;
private static Bank getInstance(){
// 方式一：效率低
//synchronized (Bank.class) {
// if(instance == null){
// instance = new Bank();
// }
// return instance;
//}
// 方式二：效率更高
if (instance == null){
synchronized (Bank.class) {
if(instance == null){
instance = new Bank();
}
}
}
return instance;
}
}
死锁问题：
1、死锁：不同的线程分别占用对方需要的同步资源不放弃，都在等待对方放弃自己需要的同步资源，就形成了线程的死锁
2、说明：出现死锁后，不会出现异常，不会出现提示，只是所有的线程都处于阻塞状态，无法继续
//DeadLock.java
/**
* 死锁演示
* 分析：
* 在子线程b中，调用了主线程a的last()方法
* 在主线程a中，调用了子线程b的last()方法
* 互相调用形成死循环
*/
public class DeadLock implements Runnable {
A a = new A();
B b = new B();
public void init(){
Thread.currentThread().setName("主线程");
a.foo(b);
System.out.println("进入到了主线程之后");
}
@Override
public void run() {
Thread.currentThread().setName("副线程");
b.bar(a);
System.out.println("进入到副线程之后");
}
public static void main(String[] args) {
//子线程
DeadLock d1 = new DeadLock();
new Thread(d1).start();
//主线程
d1.init();
}
}
ba
class A{
public synchronized void foo(B b){
System.out.println("当前线程名：" + Thread.currentThread().getName() + " 进入了A实例的foo方法");
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("当前线程名：" + Thread.currentThread().getName() + " 企图调用B实例的last方法");
b.last();
}
public synchronized void last(){
System.out.println("进入到A类的last方法的内部");
}
}
class B{
public synchronized void bar(A a){
System.out.println("当前线程名：" + Thread.currentThread().getName() + " 进入了B实例的bar方法");
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("当前线程名：" + Thread.currentThread().getName() + " 企图调用A实例的last方法");
a.last();
}
public synchronized void last(){
System.out.println("进入到B类的last方法的内部");
}
}
锁的操作
释放锁的操作：
- 当前线程的同步代码块、同步方法执行结束
- 当前线程的同步代码块、同步方法执行遇到break、return终止了该代码块、该方法的继续执行
- 当前线程的同步代码块、同步方法执行出现了未处理的Error或Exception，导致异常结束
- 当前线程的同步代码块、同步方法执行了线程对象的wait()方法，当前线程暂停，并释放锁
不释放锁的操作：
- 线程执行同步代码块或同步方法时，程序调用Thread.sleep()、Thread.yield()方法暂停当前线程的执行
- 线程执行同步代码块时，其它线程调用了该线程的suspend()方法将该线程挂起，该线程不释放锁(同步监视器)
线程的通信
通信的三个方法：
- wait():一旦执行此方法，当前线程就进入阻塞状态，并释放同步监视器
- notify():一旦执行此方法，就会唤醒被wait的一个线程。如果有多个线程被wait，就会唤醒优先级高的那个
- notifyAll():一旦执行此方法，就会唤醒所有被wait的线程。
说明：
- 三个方法必须使用在同步代码块或同步方法中
- 三个方法的调用者必须是同步代码块或同步方法中的同步监视器，否者会报错-IllegalMonitorStateException
- 三个方法都是定义在Object类
面试题：sleep()和wait()的异同？
相同：一旦执行方法，都可以使得当前的线程进入阻塞状态
不同：
- 两个方法声明的位置不同：Thread类中声明sleep(),Object类中声明wait()
- 调用的要求不同：sleep()方法可以在任意需要的场景下调用，wait()必须使用在同步代码块中
- 关于是否释放同步监视器：两个方法都使用在同步代码块或同步方法中，sleep()不释放同步监视器，wait()需要释放同步监视器
//CommunicationTest.java
/**
* 线程通信的示例：使用两个线程打印 1-100，线程1和线程2 交替打印
*/
public class CommunicationTest {
public static void main(String[] args) {
Number number = new Number();
Thread t1 = new Thread(number);
Thread t2 = new Thread(number);
t1.setName("线程1");
t2.setName("线程2");
t1.start();
t2.start();
}
}
class Number implements Runnable{
private int number =1;
private Object obj = new Object();
@Override
public void run() {
while(true){
synchronized (obj) {
obj.notify(); //唤醒等待的线程
if(number <= 100){
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + ":" + number);
number++;
try {
obj.wait(); //使得调用wait()方法的线程进入阻塞状态
} catch (InterruptedException e) {
e.printStackTrace();
}
}else {
break;
}
}
}
}
}
案例：生产者/消费者问题
//ProductTest.java
/**
* 线程通信的应用：生产者/消费者问题
* <p>
* 生产者（Producer）将产品交给店员（clerk），消费者（Customer）从店员处取走产品，
* 店员一次只能持有固定数量的产品（如：20），如果生产者试图生产更多的产品，店员会叫生产者停一下，
* 如果店中有空位放产品了，再通知生产者继续生产；如果店中没有产品，店员会告诉消费者等一下，
* 如果店中有产品了再通知消费者来取走产品
* <p>
* 分析：
* 1、是否多线程问题？ 是，生产者线程，消费者线程
* 2、是否公共享数据？是，店员
* 3、如何解决线程安全问题？同步机制，有三种
* 4、是否涉及线程通信？是
*/
public class ProductTest {
public static void main(String[] args) {
Clerk clerk = new Clerk();
Producer p = new Producer(clerk);
p.setName("生产者1");
Consumer c = new Consumer(clerk);
c.setName("消费者1");
Consumer c2 = new Consumer(clerk);
c2.setName("消费者2");
p.start();
c.start();
c2.start();
}
}
/**
* 店员：共享数据
*/
class Clerk {
private int productCount = 0;
//生产产品
public synchronized void produceProduct() {
if (productCount < 20) {
productCount++;
System.out.println(Thread.currentThread().getName() + ":开始生产第" + productCount + "产品");
notify(); //唤醒消费者线程
} else {
try {
wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
//消费产品
public synchronized void consumeProduct() {
if (productCount > 0) {
System.out.println(Thread.currentThread().getName() + ":开始消费第" + productCount + "产品");
productCount--;
notify();
} else {
try {
wait(); //等待
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
/**
* 生产者
*/
class Producer extends Thread {
private Clerk clerk;
public Producer(Clerk clerk) {
this.clerk = clerk;
}
@Override
public void run() {
System.out.println(getName() + ":开始生产。。。");
while (true) {
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
clerk.produceProduct();
}
}
}
/**
* 消费者
*/
class Consumer extends Thread {
private Clerk clerk;
public Consumer(Clerk clerk) {
this.clerk = clerk;
}
@Override
public void run() {
System.out.println(getName() + ":开始消费。。。");
while (true) {
try {
Thread.sleep(20);
} catch (InterruptedException e) {
e.printStackTrace();
}
clerk.consumeProduct();
}
}
}
JDK5新增的线程创建方式
方式三：实现Callable接口
call() ：该方法为实现Callable接口重写的方法
new FutureTask()：其构造器接受一个实现Callable接口的实现类的对象
get(): FutureTask类创建出的对象可以调用get()方法获取call() 的返回值
示例三：
//ThreadNew.java
/**
* 线程的创建方式三：实现Callable接口 -> jdk5.0+
*/
public class ThreadNew {
public static void main(String[] args) {
//3、创建Callable接口实现类的对象
NumThread numThread = new NumThread();
//4、将此对象作为FutureTask构造器的参数
FutureTask futureTask = new FutureTask(numThread);
//5、将FutureTask的对象作为参数传递到Thread类的构造器中，创建Thread对象，并调用start()
new Thread(futureTask).start();
try {
//6、获取Callable中的call()方法的返回值
//get()方法返回call()方法的返回指
Object sum = futureTask.get();
System.out.println("100以内偶数之和：" + sum);
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}
}
}
// 1、创建一个实现Callable接口的实现类
class NumThread implements Callable {
//2、实现call方法，将此线程需要执行的方法声明再次
@Override
public Object call() throws Exception {
int sum = 0;
for (int i = 0; i < 100; i++) {
if (i % 2 == 0) {
System.out.println(i);
sum += i;
}
}
return sum;
}
}
面试题：如何理解Callable接口比Runnable接口功能更加强大？
- call()可以有返回值
- call()可以抛异常，被外面的操作捕获，获取异常的信息
- Callable支持泛型
方式四：使用线程池
JDK5.0提供关于线程池API：
-
ExecutorService：线程池接口，其常用子类ThreadPoolExecutor //ThreadPoolExecutor的方法
-
public void execute(Runnable command) //执行任务或命令，一般用来执行Runnable
-
Future submit(Callable task); //执行任务或命令，一般用来执行Callable -
void shoutdown() //关闭连接池
-
-
Executors：工具类、线程池的工厂类，用于创建并返回不同类型的线程池
-
Executors.newCachedThreadPool(); //创建一个可根据需要创建新线程的线程池
-
Executors.newFixedThreadPool(n); //创建一个可重用固定线程数的线程池
-
Executors.newSingleThreadExcutor();//创建一个只有一个线程的线程池
-
Executors.newScheduleThreadPool(n); //创建一个线程池，它可安排在给定延迟后运行或者定期地执行
-
优势：
- 提高响应速度（减少创建新线程的时间）
- 降低资源消耗（重复利用线程池中的线程，不需要每次创建）
- 便于线程管理
- corePoolSize:核心池的大小
- maximumPoolSize:最大线程数
- keepAliveTime：线程没有任务时最多保持多长的时间后终止
示例四：
//ThreadPool.java
/**
* 多线程的创建方式四：使用线程池
*/
public class ThreadPool {
public static void main(String[] args) {
//1、提供指定线程数量的线程池
ExecutorService service1 = Executors.newFixedThreadPool(10);
ThreadPoolExecutor service = (ThreadPoolExecutor) service1;
System.out.println("service的实现类：" + service.getClass());
//设置线程池参数
//service.setCorePoolSize(15);
//2、执行指定的线程的操作，需要提供实现Runnable接口或Callable接口的实现类对象
//适用Runnable接口实现类的对象
service.execute(new NumberThread());
service.execute(new NumberThread2());
//适用Callable接口实现类对象
//service.submit();
//3、关闭线程池连接
service.shutdown();
}
}
class NumberThread implements Runnable {
@Override
public void run() {
for (int i = 0; i < 100; i++) {
if (i % 2 == 0) {
System.out.println(Thread.currentThread().getName() + ":" + i);
}
}
}
}
class NumberThread2 implements Runnable {
@Override
public void run() {
for (int i = 0; i < 100; i++) {
if (i % 2 != 0) {
System.out.println(Thread.currentThread().getName() + ":" + i);
}
}
}
}
