匿名内部类创建线程（什么是多线程操作）

本文目录

• 什么是多线程操作
• 编写程序，创建新线程，main线程和新线程各自执行20次，新线程每一秒执行一次
• Vivox9多线程设置怎么开
• 如何通过使用匿名内部类来将线程代码隐藏在类中

什么是多线程操作

多线程的概念？
说起多线程，那么就不得不说什么是线程，而说起线程，又不得不说什么是进程。
进程（Process）是计算机中的程序关于某数据集合上的一次运行活动，是系统进行资源分配和调度的基本单位，是操作系统结构的基础。在早期面向进程设计的计算机结构中，进程是程序的基本执行实体；在当代面向线程设计的计算机结构中，进程是线程的容器。程序是指令、数据及其组织形式的描述，进程是程序的实体。
进程可以简单的理解为一个可以独立运行的程序单位。它是线程的集合，进程就是有一个或多个线程构成的，每一个线程都是进程中的一条执行路径。
那么多线程就很容易理解：多线程就是指一个进程中同时有多个执行路径（线程）正在执行。
为什么要使用多线程？
1.在一个程序中，有很多的操作是非常耗时的，如数据库读写操作，IO操作等，如果使用单线程，那么程序就必须等待这些操作执行完成之后才能执行其他操作。使用多线程，可以在将耗时任务放在后台继续执行的同时，同时执行其他操作。
2.可以提高程序的效率。
3.在一些等待的任务上，如用户输入，文件读取等，多线程就非常有用了。
缺点：
1.使用太多线程，是很耗系统资源，因为线程需要开辟内存。更多线程需要更多内存。
2.影响系统性能，因为操作系统需要在线程之间来回切换。
3.需要考虑线程操作对程序的影响，如线程挂起，中止等操作对程序的影响。
4.线程使用不当会发生很多问题。
总结：多线程是异步的，但这不代表多线程真的是几个线程是在同时进行，实际上是系统不断地在各个线程之间来回的切换（因为系统切换的速度非常的快，所以给我们在同时运行的错觉）。
2.多线程与高并发的联系。
高并发：高并发指的是一种系统运行过程中遇到的一种“短时间内遇到大量操作请求”的情况，主要发生在web系统集中大量访问或者socket端口集中性收到大量请求（例如：12306的抢票情况；天猫双十一活动）。该情况的发生会导致系统在这段时间内执行大量操作，例如对资源的请求，数据库的操作等。如果高并发处理不好，不仅仅降低了用户的体验度（请求响应时间过长），同时可能导致系统宕机，严重的甚至导致OOM异常，系统停止工作等。如果要想系统能够适应高并发状态，则需要从各个方面进行系统优化，包括，硬件、网络、系统架构、开发语言的选取、数据结构的运用、算法优化、数据库优化……。
而多线程只是在同/异步角度上解决高并发问题的其中的一个方法手段，是在同一时刻利用计算机闲置资源的一种方式。
多线程在高并发问题中的作用就是充分利用计算机资源，使计算机的资源在每一时刻都能达到最大的利用率，不至于浪费计算机资源使其闲置。
3.线程的创建，停止，常用方法介绍。
1.线程的创建：
线程创建主要有2种方式，一种是继承Thread类，重写run方法即可；（Thread类实现了Runable接口）
另一种则是实现Runable接口，也需要重写run方法。
线程的启动，调用start（）方法即可。 我们也可以直接使用线程对象的run方法，不过直接使用，run方法就只是一个普通的方法了。

其他的还有： 通过匿名内部类的方法创建；实现Callable接口。。。。。

2.线程常用方法：
currentThread()方法：该方法返回当前线程的信息 .getName（）可以返回线程名称。

isAlive()方法：该方法判断当前线程是否处于活动状态。
sleep()方法：该方法是让“当前正在执行的线程“休眠指定的时间，正在执行的线程是指this.currentThread()返回的线程。
getId()方法：该方法是获取线程的唯一标识。
3.线程的停止：
在java中，停止线程并不简单，不想for。。break那样说停就停，需要一定的技巧。

线程的停止有3种方法：
1.线程正常终止，即run()方法运行结束正常停止。
2.使用interrupt方法中断线程。
3.使用stop方法暴力停止线程。
interrupt方法中断线程介绍：
interrupt方法其实并不是直接中断线程，只是给线程添加一个中断标志。
判断线程是否是停止状态：
this.interrupted(); 判断当前线程是否已经中断。（判断的是这个方法所在的代码对应的线程，而不是调用对象对应的线程）

this.isInterrupted(); 判断线程是否已经中断。（谁调用，判断谁）

注：.interrupted()与isInterrupted()的区别：
interrupted()方法判断的是所在代码对应的线程是否中断，而后者判断的是调用对象对应的线程是否停止
前者执行后有清除状态的功能（如连续调用两次时，第一次返回true，则第二次会返回false）
后者没有清除状态的功能（两次返回都为true）
真正停止线程的方法：
异常法：
在run方法中 使用 this.interrupted();判断线程终止状态，如果为true则 throw new interruptedException()然后捕获该异常即可停止线程。

return停止线程：
在run方法中 使用 this.interrupted();判断线程终止状态，如果为true则return停止线程。 （建议使用异常法停止线程，因为还可以在catch中使线程向上抛，让线程停止的事件得以传播）。

暴力法：
使用stop()方法强行停止线程（强烈不建议使用，会造成很多不可预估的后果，已经被标记为过时）
（使用stop方法会抛出 java.lang.ThreadDeath 异常，并且stop方法会释放锁，很容易造成数据不一致）
注：在休眠中停止线程：
在sleep状态下停止线程 会报异常，并且会清除线程状态值为false；
先停止后sleep，同样会报异常 sleep interrupted；

4.守护线程。
希望对您有所帮助！~

编写程序，创建新线程，main线程和新线程各自执行20次，新线程每一秒执行一次

public class Day13C {

public static void main(String args) {

int m=0;

new Thread(new Runnable() {

public void run() {

int n=0;

while(++n《=20) {

try {

Thread.sleep(1000);

}catch (InterruptedException e) {

e.printStackTrace();

}

System.out.println(“World...“+n);

}

}).start();

while(++m《=20) {

System.out.println(“Hello...“+m);

}

}

}

Vivox9多线程设置怎么开

开启Vivox9多线程设置
要开启一个多线程有两种方法：

1、继承 Thread 类

通过继承 Thread 类的方式实现多线程有4个步骤：

《1》create 一个类，让它继承 Thread 类

《2》重写 Thread 类里面的 run 方法，把需要执行的代码块放在 run 方法体内

《3》在主线程（主程序）内创建该类的对象

《4》用该对象调用 start 方法

例子：

package multiThread;

public class jichengThread {

public static void main(Stringargs){
myThread mt = new myThread();
mt.start();
for(int i=0;i《1000;i++)
System.out.println(“主线程程序在执行.......“);
}

}

class myThread extends Thread{
public void run(){
for(int i=0;i《1000;i++)
System.out.println(“子线程程序在执行.......“);
}
}
执行结果：可以看到两个线程在同时执行

但是有时候即使开启了一个多线程（开启多线程就是CPU在执行主程序的时候，同时分配一些空间执行子程序），但是还是看不到两个线程在同时执行，那有可能是主线程的程序执行时间太短，没有看到交替执行的结果，比如在 for 循环里面把循环的次数减小到10，就看不到交替执行的结果，但其实还是多线程

除了创建两个类之外，还可以用匿名内部类的方式继承 Thread 类，重写 Thread 里面的run 方法，调用 start() 方法，实现多线程，如下：

（匿名内部类就是创建一个类的对象，并不给其赋给对应的引用，如下面的 new Thread() 创建了一个 Thread 的对象，米有给其赋给一个引用，而 new Thread 后面跟小括号、大括号，表示该类继承Thread类，并创建了一个Thread类的子类对象，里面的 run 方法表示重写该方法，最终相当于创建了一个 Thread 类的对象，再调用 start 方法执行线程）

package multiThread;

public class nimingneibuleishixian {

public static void main(String args) {
new Thread(){
@Override
public void run() {
for(int i=0;i《1000;i++)
System.out.println(“子线程在执行....“);
}
}.start();

for(int i=0;i《1000;i++){
System.out.println(“主线程在执行....“);
}
}
}
运行结果：

2、实现 Runable 接口

通过该方法实现多线程的步骤如下：

《1》创建一个类，实现Runnable 接口

《2》重写 run 方法（注意：run 方法是 Runnable 接口里面唯一的方法，Thread 类也是实现了 Runnable 接口）

《3》创建该类的一个对象

《4》调用 Thread 类的有参构造，把上一步创建的对象作为参数传递，创建 Thread 类的一个对象

《5》调用该对象的 start 方法

如何通过使用匿名内部类来将线程代码隐藏在类中

class InnerThread1{ private int countDown=5; private Inner inner; private class Inner extends Thread{ Inner(String name) { super(name); start(); } @Override public void run() { while(true){ try {
System.out.println(this); if(--countDown==0) return; TimeUnit.MILLISECONDS.sleep(10); } catch (InterruptedException e) {
System.out.println(“interrupted“); }
}
} public String toString(){ return getName()+“:“+countDown; }
} public InnerThread1(String name){ inner=new Inner(name); }
}class InnerThread2{ private int countDown=5; private Thread t; public InnerThread2(String name){ t=new Thread(name){ @Override public void run() { while(true){ try {
System.out.println(this); if(--countDown==0) return; TimeUnit.MILLISECONDS.sleep(10); } catch (InterruptedException e) {
System.out.println(“sleep() interrupted“); }
}
} public String toString(){ return getName()+“:“+countDown; }
}; t.start(); }
}class InnerRunnable1{ private int countDown=5; private Inner inner; private class Inner implements Runnable{
Thread t; Inner(String name){ t=new Thread(this,name); t.start(); } @Override public void run() { try { while(true) {
System.out.println(this); if (--countDown == 0) return; TimeUnit.MILLISECONDS.sleep(10); }
} catch (InterruptedException e) {
System.out.println(“sleep() interrupted“); }
} public String toString(){ return t.getName()+“: “+countDown; }
} public InnerRunnable1(String name){ inner=new Inner(name); }
}class InnerRunnable2{ private int countDown=5; private Thread t; public InnerRunnable2(String name){ t=new Thread(new Runnable() { @Override public void run() { while(true){
System.out.println(this); if(--countDown==0) return; try {
TimeUnit.MILLISECONDS.sleep(10); } catch (InterruptedException e) {
System.out.println(“sleep() interrupted“); }
}
} public String toString(){ return Thread.currentThread().getName()+“: “+countDown; }
},name); }
}class ThreadMethod{ private int countDown=5; private Thread t; private String name; public ThreadMethod(String name){ this.name=name; } public void runTask(){ if(t==null){ t=new Thread(name){ @Override public void run() { while(true){
System.out.println(this); if(--countDown==0) return; try {
TimeUnit.MILLISECONDS.sleep(10); } catch (InterruptedException e) {
System.out.println(“sleep() interrupted“); }
}
} public String toString(){ return getName()+“: “+countDown; }
}; t.start(); }
}
}public class ThreadVariations { public static void main(String args){ new InnerThread1(“InnerThread1“); new InnerThread2(“InnerThread2“); new InnerRunnable1(“InnerRunnable1“); new InnerRunnable2(“InnerRunnable2“); new ThreadMethod(“ThreadMethod“).runTask(); }
}