编程语言
首页 > 编程语言> > java多线程基础知识(1)

java多线程基础知识(1)

作者:互联网

实现多线程的方式

Thread的构造方法

//分配一个新的 Thread对象。
Thread()

//分配一个新的 Thread对象。
Thread(Runnable target)

//分配一个新的 Thread对象。
Thread(Runnable target, String name)

//分配一个新的 Thread对象。
Thread(String name)

//分配一个新的 Thread对象。
Thread(ThreadGroup group, Runnable target)

//分配一个新的 Thread对象,使其具有 target作为其运行对象,具有指定的 name作为其名称,属于 group引用的线程组。
Thread(ThreadGroup group, Runnable target, String name)

//分配一个新的 Thread对象,以便它具有 target作为其运行对象,将指定的 name正如其名,以及属于该线程组由称作 group ,并具有指定的 堆栈大小 。
Thread(ThreadGroup group, Runnable target, String name, long stackSize)

//分配一个新的 Thread对象。
Thread(ThreadGroup group, String name)

其中最常用的是空参的构造和传入一个runnable接口这种方式。需要注意的是Thread也实现了Runnable接口,所以也可以传入一个Thread类的对象。

继承Thread类方式

public class Mythread extends Thread{
    @Override
    public void run() {
        super.run();
        System.out.println("myThread");
    }
}

public class TestThread {
    public static void main(String[] args) {
        Mythread mythread=new Mythread();
        mythread.start();
    }
}

实现Runable接口

public class MyRunnable implements Runnable{
    @Override
    public void run() {
        System.out.println("myRunnable");
    }
}
public class TestThread {
    public static void main(String[] args) {
        Thread thread=new Thread(new MyRunnable());
        thread.start();
    }
}

使用Callable和Future创建线程

具体是创建Callable接口的实现类,并实现call方法,并且使用FutureTask类来包装Callable实现类的对象,最后把FutureTask对象作为Thread的target来创建线程,如下:

public class MyCallable implements Callable {
    @Override
    public Object call() throws Exception {
        System.out.println("myCallable");
        return "hello callable";
    }
}
public class TestThread {

    public static void main(String[] args) {
        Callable callable=new MyCallable();
        FutureTask futureTask=new FutureTask(callable);
        Thread thread=new Thread(futureTask);
        thread.start();

        try {
            Object object = futureTask.get();	//获取call方法的返回值
            System.out.println(object);	//hello callable
        }catch (Exception e) {
            e.printStackTrace();
        }
    }
}

以上就是实现多线程的三种方式。
第三种方式之所以可以,是因为FutureTask实现了Runnable接口而已。

多线程的常用方法

currentThread()

可以返回代码段正在被哪个线程调用的信息,如下:

public class Mythread extends Thread{

 	public Mythread(){
        System.out.println("构造:"+Thread.currentThread().getName());	//构造:main
    }
    @Override
    public void run() {
        super.run();
        System.out.println(Thread.currentThread().getName());		//Thread-0
    }
	/**
	从运行结果可以看出,Mythread类的构造方法是被main线程调用的,而run方法是被Thread-0线程调用的,run方式是自动调用的方法
	*/
}
public class TestThread {

    public static void main(String[] args) {
        Mythread mythread=new Mythread();
        mythread.start();
        System.out.println(Thread.currentThread().getName());		//main
    }
}

标签:Runnable,java,String,Thread,基础知识,Mythread,多线程,public,target
来源: https://www.cnblogs.com/bill-g-chen/p/15700089.html