java怎么创建一个线程

Posted 2023-04-05

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。

实现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”。

参考技术A

Java线程类也是一个object类,它的实例都继承自java.lang.Thread或其子类

创建线程

Tread thread = new Thread();

运行线程

thread.start();

运用场景

创建Thread的子类

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


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

实现Runnable接口

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


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

参考技术B

方法如下：

/**
 * 常用的有3中方法，供参考
 * 
 * @author qd
 *
 */
public class MyThread extends Thread 

    @Override
    public void run() 

        System.out.println("线程已启动。。。");
    

    public static void main(String[] args) 

        MyThread myThread = new MyThread();
        // 调用start方法启动线程
        myThread.start();

        MyThread1 myThread1 = new MyThread1();
        Thread thread = new Thread(myThread1);
        // 调用start方法启动线程
        thread.start();
    



/**
 * 方法二：实现Runnable接口
 * 
 * @author qd
 *
 */
class MyThread1 implements Runnable 

    @Override
    public void run() 

        System.out.println("run方法里面编写业务代码");
    



/**
 * 方法三：实现Callable<T>接口 优点：可以传参数，有返回值类型
 * 
 * @author qd
 *
 */
class MyThread2 implements Callable<Integer> 

    @Override
    public Integer call() throws Exception 
        return null;
    

运行效果:

JAVA线程能创建线程吗

Java有三种创建线程的方式，分别是继承Thread类、实现Runable接口和使用线程池
1、继承Thread类
使用该方式创建及使用线程需按以下三个步骤：
（1）定义Thread类的子类，并重写父类的run()方法，方法里的内容就是线程所要执行的任务；
（2）创建子类的实例，即生成线程的实例对象；
（3）调用现成的start()方法来启动线程。
public class SubThread extends Thread
private int ticket = 100; private String name; public ImplThread(String name) this.name = name;
public void run() while (k > 0)
System.out.println(ticket-- + "is saled by" + name);
try
sleep((int)Math.random() * 10);
catch (InterruptedException e)
e.printStackTrace();

public static void main (String []args)
SubThread t1 = new SubThread("A");
SubThread t2 = new SubThread("B");
t1.start();
t2.start();

1234567891011121314151617181920212223

2、实现Runnable接口
（1）定义实现Runnable接口的实现类，并重写run()方法；
（2）创建Runnable接口实现类的实例，并将该实例作为参数传到Thread类的构造方法中来创建Thread对象，该Thread对象才是真正的线程对象；
（3）调用现成的start()方法来启动线程。
public class ImplThread implements Runnable
private int ticket = 100; private String name; public ImplThread(String name) this.name = name;
public void run() while (k > 0)
System.out.println(ticket-- + "is saled by" + name);
try
sleep((int)Math.random() * 10);
catch (InterruptedException e)
e.printStackTrace();

public static void main (String []args)
ImplThread i1 = new ImplThread("A");
ImplThread i2 = new ImplThread("B");
Thread t1 = new Thread(i1);
Thread t2 = new Thread(i2);
t1.start();
t2.start();

12345678910111213141516171819202122232425

上面这段代码跟继承Thread类的线程代码呈现的效果是一样的，虽然执行的是相同的代码，但彼此相互独立，且各自拥有自己的资源，互不干扰。
但是，在某些场景，我们希望各线程能共享资源，这时候就只能扩展Runnable接口了。
public class ImplThread implements Runnable
private int ticket = 100; public void run() while (k > 0)
System.out.println(ticket-- + "is saled by" + Thread.currentThread());
try
sleep((int)Math.random() * 10);
catch (InterruptedException e)
e.printStackTrace();

public static void main (String []args)
ImplThread i = new ImplThread();
Thread t1 = new Thread(i);
Thread t2 = new Thread(i);
t1.start();
t2.start();

1234567891011121314151617181920

这时候，线程t1和t2共享这100张票。
3、使用线程池
使用线程池并不是创建线程，而是对线程进行管理。Excetor为线程池超级接口，该接口中定义了一个execute(Runnable command)方法，用来执行传递过来的线程，ExecutorService就是我们所说的线程池，它继承了Excetor接口。如何创建线程池呢？Java提供了Executors类，该类有四个静态方法分别可以创建不同类型的线程池（ExecutorService）。
Executors.newCachedThreadPool() 创建可变大小的线程池
Executors.newFixedThreadPool(int number) 创建固定大小的线程池
Executors.newSingleThreadPool() 创建单任务线程池
Executors.newScheduledThreadPool(int number) 创建延迟线程池
import java.util.concurrent.Executors;
import java.util.concurrent.ExecutorService;
public class Test 　　public static void main(String[] args)
//创建一个可重用固定线程数的线程池 　　ExecutorService pool = Executors.newFixedThreadPool(2);
//创建实现了Runnable接口对象，Thread对象当然也实现了Runnable接口 　　Thread t1 = new MyThread();
Thread t2 = new MyThread();
Thread t3 = new MyThread();
Thread t4 = new MyThread();
Thread t5 = new MyThread();
//将线程放入池中进行执行 　　pool.execute(t1);
pool.execute(t2);
pool.execute(t3);
pool.execute(t4);
pool.execute(t5);
//关闭线程池 　　pool.shutdown();


class MyThread extends Thread 　　@Override
public void run()
System.out.println(Thread.currentThread().getName()+"正在执行。。。");

12345678910111213141516171819202122232425262728

输出：
pool-1-thread-1正在执行。。。
pool-1-thread-1正在执行。。。
pool-1-thread-1正在执行。。。
pool-1-thread-1正在执行。。。
pool-1-thread-2正在执行。。。
Process finished with exit code 0
可见，线程得到了重用，线程池里只有两个线程在执行。 参考技术A 当然可以，没有限制创建线程的必须是主线程。
Java使用Thread类代表线程，所有的线程对象都必须是Thread类或其子类的实例。Java可以用三种方式来创建线程，如下所示：
1）继承Thread类创建线程
2）实现Runnable接口创建线程
3）使用Callable和Future创建线程