当前位置：首页 » 编程语言 » java创建一个线程

java创建一个线程

发布时间: 2021-03-11 20:04:54

㈠ java中如何启动一个新的线程

java开启新线程的三种方法：

方法1：继承Thread类

1）：定义一个继承自Java.lang.Thread类的类A.

2）：覆盖A类Thread类中的run方法。

3）：我们编写需要在run方法中执行的操作：run方法中的代码，线程执行体。

4）：在main方法（线程）中，创建一个线程对象并启动线程。

(1)创建线程类对象:

A类 a = new A类();

(2)调用线程对象的start方法:

a.start();//启动一个线程

注意：不要调用run方法。如果run方法被称为对象调用方法，则仍然只有一个线程，并且没有启动新线程。

创建启动线程实例：

(1)java创建一个线程扩展阅读：

启动新线程的两种方式对比

继承方式:

1):从设计上分析，Java中类是单继承的,如果继承了Thread了,该类就不能再有其他的直接父类了.

2):从操作上分析,继承方式更简单,获取线程名字也简单.(操作上,更简单)

3):从多线程共享同一个资源上分析,继承方式不能做到.

实现方式:

1):从设计上分析，Java中类可以多实现接口,此时该类还可以继承其他类,并且还可以实现其他接口，设计更为合理.

2):从操作上分析,实现方式稍微复杂点,获取线程名字也比较复杂,得使用Thread.currentThread()来获取当前线程的引用.

3):从多线程共享同一个资源上分析,实现方式可以做到(是否共享同一个资源).

补充：实现方式获取线程名字：

String name = Thread.currentThread().getName();

㈡在JAVA 中怎样创建一个线程

package test;
import java.util.*;

public class Threadtest extends Thread{
int pauseTime;
String name;
public Threadtest(int time,String n){
pauseTime = time;
name = n;
}
public void run(){
Calendar now;
now = Calendar.getInstance();
System.out.println(name+now.get(Calendar.MINUTE)+now.get(Calendar.SECOND));
try{
Thread.sleep(pauseTime);
}catch(Exception e){
e.getStackTrace();
}
Threadtest2 myt1 = new Threadtest2(5000,"threadin;;");
myt1.start();
}
public static void main(String[] args){
Threadtest myt1 = new Threadtest(2000,"thread1;;");
myt1.start();
Threadtest myt2 = new Threadtest(1000,"thread2;;");
myt2.start();
}

}
class Threadtest2 extends Thread{
int pauseTime;
String name;
public Threadtest2(int time,String n){
pauseTime = time;
name = n;
}
public void run(){
Calendar now;
now = Calendar.getInstance();
System.out.println(name+now.get(Calendar.MINUTE)+now.get(Calendar.SECOND));
try{
Thread.sleep(pauseTime);
}catch(Exception e){
e.getStackTrace();
}
}

}

㈢ Java开发如何创建一个线程

（1）通过扩展Thread类来创建多线程

publicstaticvoidmain(String[]args){
MutliThreadm1=newMutliThread("Window1");
MutliThreadm2=newMutliThread("Window2");
MutliThreadm3=newMutliThread("Window3");
m1.start();
m2.start();
m3.start();
}
}
classMutliThreadextendsThread{
privateintticket=100;//每个线程都拥有100张票
MutliThread(Stringname){
super(name);//调用父类带参数的构造方法
}
publicvoidrun(){
while(ticket>0){
System.out.println(ticket--+"issaledby"+Thread.currentThread().getName());
}
}
}

（2）通过实现Runnable接口来创建多线程

publicstaticvoidmain(String[]args){
MutliThreadm1=newMutliThread("Window1");
MutliThreadm2=newMutliThread("Window2");
MutliThreadm3=newMutliThread("Window3");
Threadt1=newThread(m1);
Threadt2=newThread(m2);
Threadt3=newThread(m3);
t1.start();
t2.start();
t3.start();
}
}
{
privateintticket=100;//每个线程都拥有100张票
privateStringname;
MutliThread(Stringname){
this.name=name;
}
publicvoidrun(){
while(ticket>0){
System.out.println(ticket--+"issaledby"+name);
}
}
}

㈣ Java 如何创建100个Thread 线程

“创建100个线程”和“创建1个线程”是一样的。
(如果不一样，只可能是你问得唐突、不清晰)
你可以把100个线程放到一个数组中。
Thread threads[]=new Thread[100];
//然后逐个生成启动
for(int i=0;i<100;i++){
threads[i]=new Thread(//put some runnable here );
threads[i].start();
}

㈤在 java中，怎样创建一个线程

两种创建新线程的方式
1.定义Runnable接口的实现类,重写run()方法
创建线程的实例的时候将这个类的实例作为参数传递到线程实例内部。然后再启动：
MyRun mr = new MyRun();
Thread t1 = new Thread(mr);
t1.start();

public class TestThread1 {
public static void main(String[] args) {
Runner runner = new Runner();//创建Runnable实现类的对象
Thread thread1 = new Thread(runner);
thread1.start();//启动一个子线程
for(int i = 0; i < 100; i++){
System.out.println("-------Main Thread:" + i);
}
}
}

class Runner implements Runnable{
public void run() {
for(int i = 0; i < 100; i++){
System.out.println("runner:" + i);
}
}
}

2.定义Thread 的子类,重写run()方法
创建此线程类的实例并启动：
MyThread t1 = new MyThread();
t1.start();

public class TestThread2 {
public static void main(String[] args) {
MyThread thread1 = new MyThread();
thread1.start();
for(int i = 0; i < 100; i++){
System.out.println("-------Main Thread:" + i);
}
}
}

class MyThread extends Thread{
public void run() {
for(int i = 0; i < 100; i++){
System.out.println("MyThread:" + i);
}
}
}

㈥ java 如何创建一个有返回值的线程

可以通过实现Callable接口创建一个有返回值的线程，代码如下：

importjava.util.concurrent.*;


<Integer>{

privateintcount;

publicMyThread(intcount){
this.count=count;
}

@Override
publicIntegercall()throwsException{
//此处是线程要处理的业务代码，此处实现的是对count变量加1的操作
count+=1;
Thread.sleep(1000);
returncount;
}

publicstaticvoidmain(String[]args){

//创建线程实例
MyThreadmyThread=newMyThread(1);

//创建一个大小为10的线程池
ExecutorServiceexecutor=Executors.newFixedThreadPool(10);

//将线程提交到线程池执行
Future<Integer>future=executor.submit(myThread);

try{
//调用get方法获取线程执行结果，在线程执行完成前该方法会一直阻塞
Integerresult=future.get();
System.out.println(result);
}catch(InterruptedExceptione){
e.printStackTrace();
}catch(ExecutionExceptione){
e.printStackTrace();
}


//try{
////这种写法可以设置线程执行的超时时间，当线程超过指定的时间还未执行完成时会抛出TimeoutException异常
////示例中表示线程超过1000毫秒还没执行完就会抛出超时异常
//Integerresult=future.get(1000,TimeUnit.MILLISECONDS);
//System.out.println(result);
//}catch(InterruptedExceptione){
//e.printStackTrace();
//}catch(ExecutionExceptione){
//e.printStackTrace();
//}catch(TimeoutExceptione){
//e.printStackTrace();
//}
}
}

㈦ java创建线程有几种方式

java创建线程的方式有三种
第一种是继承Thread类实现方法run() 不可以抛异常无返回值
第二种是实现Runnable接口实现方法run() 不可以抛异常无返回值
第三种是实现Callable<T>接口,接口中要覆盖的方法是 public <T> call() 注意:此方法可以抛异常,而前两种不能而且此方法可以有返回值

第三种如何运行呢 Callable接口在util.concurrent包中,由线程池提交
import java.util.concurrent.*;
ExecutorService e = Executors.newFixedThreadPool(10); 参数表示最多可以运行几个线程
e.submit(); 这个里面参数传实现Callable接口那个类的对象

㈧如何创建并运行 java 线程

1
2
3
4
5
6
7
8
9
10
11

创建线程，就是这样
extends Thread 或者 implements Runnable，但是有很多问题；

所以引申出了下面的线程池
Java通过Executors提供四种线程池，分别为：
newCachedThreadPool创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，
若无可回收，则新建线程。
newFixedThreadPool 创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。
newScheledThreadPool 创建一个定长线程池，支持定时及周期性任务执行。
newSingleThreadExecutor 创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，
保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。

㈨如何创建并运行java线程

1
2
3
4
5
6
7
8
9
10
11

创建线程，就是这样
extends Thread 或者 implements Runnable，但是有很多问题；

所以引申出了版下面的线程池权
Java通过Executors提供四种线程池，分别为：
newCachedThreadPool创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，
若无可回收，则新建线程。
newFixedThreadPool 创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。
newScheledThreadPool 创建一个定长线程池，支持定时及周期性任务执行。
newSingleThreadExecutor 创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，
保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。

㈩如何创建并运行Java线程

Java线程类也是一个object类,它的实例都继承自java.lang.Thread或其子类。可以用如下方式用java中创建一个线程：

Tread thread = new Thread();

执行该线程可以调用该线程的start()方法:

thread.start();

在上面的例子中，我们并没有为线程编写运行代码，因此调用该方法后线程就终止了。

编写线程运行时执行的代码有两种方式：一种是创建Thread子类的一个实例并重写run方法，第二种是创建类的时候实现Runnable接口。接下来我们会具体讲解这两种方法：

创建Thread的子类

创建Thread子类的一个实例并重写run方法，run方法会在调用start()方法之后被执行。例子如下：

public class MyThread extends Thread {
public void run(){
System.out.println("MyThread running");
}
}

可以用如下方式创建并运行上述Thread子类

MyThread myThread = new MyThread();
myTread.start();

一旦线程启动后start方法就会立即返回，而不会等待到run方法执行完毕才返回。就好像run方法是在另外一个cpu上执行一样。当run方法执行后，将会打印出字符串MyThread running。

你也可以如下创建一个Thread的匿名子类：

Thread thread = new Thread(){
public void run(){
System.out.println("Thread Running");
}
};
thread.start();

当新的线程的run方法执行以后，计算机将会打印出字符串”Thread Running”。

实现Runnable接口

第二种编写线程执行代码的方式是新建一个实现了java.lang.Runnable接口的类的实例，实例中的方法可以被线程调用。下面给出例子：

public class MyRunnable implements Runnable {
public void run(){
System.out.println("MyRunnable running");
}
}

为了使线程能够执行run()方法，需要在Thread类的构造函数中传入 MyRunnable的实例对象。示例如下：

Thread thread = new Thread(new MyRunnable());
thread.start();

当线程运行时，它将会调用实现了Runnable接口的run方法。上例中将会打印出”MyRunnable running”。

同样，也可以创建一个实现了Runnable接口的匿名类，如下所示：

Runnable myRunnable = new Runnable(){
public void run(){
System.out.println("Runnable running");
}
}
Thread thread = new Thread(myRunnable);
thread.start();

创建子类还是实现Runnable接口？

对于这两种方式哪种好并没有一个确定的答案，它们都能满足要求。就我个人意见，我更倾向于实现Runnable接口这种方法。因为线程池可以有效的管理实现了Runnable接口的线程，如果线程池满了，新的线程就会排队等候执行，直到线程池空闲出来为止。而如果线程是通过实现Thread子类实现的，这将会复杂一些。

有时我们要同时融合实现Runnable接口和Thread子类两种方式。例如，实现了Thread子类的实例可以执行多个实现了Runnable接口的线程。一个典型的应用就是线程池。

常见错误：调用run()方法而非start()方法

创建并运行一个线程所犯的常见错误是调用线程的run()方法而非start()方法，如下所示：

Thread newThread = new Thread(MyRunnable());
newThread.run(); //should be start();

起初你并不会感觉到有什么不妥，因为run()方法的确如你所愿的被调用了。但是，事实上,run()方法并非是由刚创建的新线程所执行的，而是被创建新线程的当前线程所执行了。也就是被执行上面两行代码的线程所执行的。想要让创建的新线程执行run()方法，必须调用新线程的start方法。

线程名

当创建一个线程的时候，可以给线程起一个名字。它有助于我们区分不同的线程。例如：如果有多个线程写入System.out，我们就能够通过线程名容易的找出是哪个线程正在输出。例子如下：

MyRunnable runnable = new MyRunnable();
Thread thread = new Thread(runnable, "New Thread");
thread.start();
System.out.println(thread.getName());

需要注意的是，因为MyRunnable并非Thread的子类，所以MyRunnable类并没有getName()方法。可以通过以下方式得到当前线程的引用：

Thread.currentThread();

因此，通过如下代码可以得到当前线程的名字：

String threadName = Thread.currentThread().getName();

线程代码举例：

这里是一个小小的例子。首先输出执行main()方法线程名字。这个线程JVM分配的。然后开启10个线程，命名为1~10。每个线程输出自己的名字后就退出。

public class ThreadExample {
public static void main(String[] args){
System.out.println(Thread.currentThread().getName());
for(int i=0; i<10; i++){
new Thread("" + i){
public void run(){
System.out.println("Thread: " + getName() + "running");
}
}.start();
}
}
}

需要注意的是，尽管启动线程的顺序是有序的，但是执行的顺序并非是有序的。也就是说，1号线程并不一定是第一个将自己名字输出到控制台的线程。这是因为线程是并行执行而非顺序的。Jvm和操作系统一起决定了线程的执行顺序，他和线程的启动顺序并非一定是一致的。

阅读全文

java创建一个线程

与java创建一个线程相关的阅读推荐