java中如何启动⼀个新的线程三种⽅法java开启新线程的三种⽅法：
⽅法1：继承Thread类
1）：定义bai⼀个继承⾃Java.lang.Thread类的du类A.
2）：覆盖zhiA类Thread类中的run⽅法。
3）：我们编写需要在run⽅法中执⾏的操作：run⽅法中的代码，线程执⾏体。
4）：在main⽅法（线程）中，创建⼀个线程对象并启动线程。
(1)创建线程类对象:
A类  a  =  new  A类();
(2)调⽤线程对象的start⽅法:
a.start();//启动⼀个线程
注意：不要调⽤run⽅法。如果run⽅法被称为对象调⽤⽅法，则仍然只有⼀个线程，并且没有启动新线程。
创建启动线程实例：
//定义⼀个类A 继承java.lang.Thread
class A extends Thread{
//A类覆盖Thread类中的 run⽅法
@Override
public void run(){
//在run⽅法填写要执⾏的操作
for (int j = 0 ;j<10;j++){
System.out.println("执⾏⽅法A的逻辑"+j);
}
}
}
public Class B{
public static void main(String[] args){
for (int i = 0;i<50 ;i++){
System.out.println(i);
if(i==10){
// 在线程中重开⼀个线程执⾏其他操作
A a = new A();
a.start();
}
try {
if (i==10){
Thread.sleep(1000);
}
}catch (InterruptedException e){
e.printStackTrace();
}java线程池创建的四种
}
}
}
⽅法2：实现Runnable接⼝
1）：定义要在java.lang.Runnable接⼝中实现的类A.请注意，A类不是线程类。2）：覆盖A类Runnable接⼝中的run⽅法。
3）：我们编写需要在run⽅法中执⾏的操作：在run⽅法中，线程执⾏。4）：在main⽅法（线程）中，创建⼀个线程对象并启动线程。
(1)创建线程类对象:
Thread  t = new Thread(new  A());
(2)调⽤线程对象的start⽅法:
t.start();
代码实例：
//定义⼀个类C 实现java.lang.Runnable 接⼝ C类不是线程类
class C implements Runnable{
//C类覆盖Runnable接⼝中的 run⽅法
@Override
public void run(){
//在run⽅法填写要执⾏的操作
for (int j = 0 ;j<10;j++){
System.out.println("执⾏⽅法C的逻辑"+j);
}
}
}
public Class B{
public static void main(String[] args){
for (int i = 0;i<100 ;i++){
System.out.println(i);
if(i==10){
/
/ 在线程中重开⼀个线程执⾏其他操作
C c = new C();
Thread t = new Thread(c);
t.start();
}
try {
if (i==10){
System.out.println(Thread.currentThread().getName());
Thread.sleep(1000);
}
}catch (InterruptedException e){
e.printStackTrace();
}
}
}
}
⽅法3：直接在函数体使⽤
public static void main(String[] args){
for (int i=0;i<20;i++){
System.out.println(i);
if(i==10){
Thread thread = new Thread(new Runnable() {
@Override
public void run() {
for(int j=0;j<10;j++){
System.out.println("j"+j);
}
}
});
thread.start();
try {
if (i==10){
System.out.println(Thread.currentThread().getName());
Thread.sleep(1000);
}
}catch (InterruptedException e){
e.printStackTrace();
}
}
}
}
弊端：
1、每次都要new thread，新建了⼀个对象，导致对象性能差。
2、线程缺乏统⼀管理，可能⽆限制新建线程，相互之间出现竞争，极可能占⽤过多系统资源导致死机或者oom。
3、缺乏更多功能，⽐如：定时定时执⾏，定期执⾏，线程中断。
相⽐new Thread⽽⾔，Java提供的四种线程池的好处在于：
  　①可复⽤存在的线程，减少对象的创建、消亡，性能较⾼。
  　②有效控制并发线程数，提⾼了系统资源的使⽤率，避免了过多争夺系统资源，导致的堵塞。
  　③提供了定时执⾏、定期执⾏、单线程、并发数控制等功能。
Java通过Executors提供了四种线程池
newCachedThreadPool:
创建⼀个可缓存的线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，如⽆回收，则新建
线程
ExecutorService cachedThreadPool = wCachedThreadPool();
for(int i=0; i<10;i++){
final int index=i;
try{
Thread.sleep(index*1000);
}catch(InterruptedException e){
e.printStackTrace();
}
@override
public  void  run(){
System.out.println(index);
}
});
}
newFixedThreadPool:
创建⼀个定长线程池，可控制线程最⼤并发数，超出的线程会在队列中等待，定长线程池的⼤⼩最好根据系统资源进⾏设置。
ExecutorService fixedThreadPool = wFixedThreadPool(3);
for (int i = 0; i < 10; i++) {
final int index = i;
@Override
public void run() {
try {
System.out.println(index);
Thread.sleep(2000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
});
}
newScheduledThreadPool:
创建⼀个定长线程池，⽀持定时及周期性任务执⾏，ScheduledExecutorService⽐Timer更安全，功能更强⼤。
ScheduledExecutorService scheduledThreadPool = wScheduledThreadPool(5);
scheduledThreadPool.schedule(new Runnable() {
@Override
public void run() {
System.out.println("delay 3 seconds");
}
}, 3, TimeUnit.SECONDS);
此表⽰为延迟3秒执⾏
scheduledThreadPool.scheduleAtFixedRate(new Runnable() {
@Override
public void run() {
System.out.println("delay 1 seconds, and excute every 3 seconds");
}
}, 1, 3, TimeUnit.SECONDS);
此表⽰为延迟1秒后每3秒执⾏⼀次
newSingleThreadPool:
创建⼀个单线程化的线程池，它只会⽤唯⼀的⼯作线程来执⾏任务，保证所有任务按照指定顺序执⾏
ExecutorService singleThreadExecutor = wSingleThreadExecutor();
for (int i = 0; i < 10; i++) {
final int index = i;
@Override
public void run() {
try {
System.out.println(index);
Thread.sleep(2000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
});
}
newCachedThreadPool 特点：
1.核⼼线程数为零
2.最⼤线程数为⽆限
3.⽆任务时，线程存活的最⼤时间为60s
4.任务队列为同步移交队列，该队列没有缓冲区，即不会有任务会在该队列中排队，每当有任务要⼊队时，队列都会将任务移交给⼀个可⽤的线程
为什么叫缓存线程池，类⽐于redis缓存：
前者缓存的是频繁要⽤到的线程；后者缓存的是频繁要⽤到的数据
前者通过缓存线程，避免了每次执⾏任务都要创建、销毁线程的开销；后者通过缓存数据，避免了每次⽤到数据都要操作db
两者都有缓存失效的时间，前者对应keepAliveTime参数，超过该参数对应的时间后，销毁线程；后者当缓存对应的真实数据被修改时，缓存失效，清除数据
为了尽量重复利⽤缓存的线程，⽽不是每次要执⾏任务时创建新的线程，应尽量使执⾏任务的时间⼩于keepAliveTime参数，默认是60s
因为是⼀个“缓存”线程池，没有缓存可以永久有效，因此核⼼线程数为0。因此任务队列的缓冲区应为空，否则即便系统有可⽤的线程资源，当有新的任务时也不会被执⾏，⽽是进⼊任务队列排队直⾄队列满，这显然是不合理的。同样由于队列缓冲区为空，每来⼀个任务时，都会在必要时新建线程执⾏任务，这就有可能导致⼤量的线程被创建，进⽽系统瘫痪。

版权声明：本站内容均来自互联网，仅供演示用，请勿用于商业和其他非法用途。如果侵犯了您的权益请与我们联系QQ:729038198，我们将在24小时内删除。