创建线程

三种创建线程的方法

Thread方法创建

//子类继承Thread并重写run（）
public class MyThread extends Thread {

    @Override

    public void run() {

        super.run();

        String name2 = getName();

        System.out.println(name2);

    }

}

public class Test01 {

    //创建线程对象   并通过start方法开启线程

    public static void main(String[] args) {

        MyThread myThread = new MyThread();

        myThread.start();

    }

}

使用Runnable创建线程

项目中经常用的方法， 该方法适合多个相同程序的代码去处理同一个资源的情况，比如卖票

//定义Runnable实现类  重写run（）
public class MyRunnable implements Runnable {

    @Override

    public void run() {

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

        System.out.println(name);

    }
}

//创建Runnable实现类的对象
public class Test02 {

    public static void main(String[] args) {

        MyRunnable myRunnable = new MyRunnable();

        Thread thread = new Thread(myRunnable);//创建Thread对象  Runnable接口的实现类对象不是线程类。无法启动一个新线程，只有Thread才能启动一个新线程

        thread.start(); 

        //获取主线程的名字

        System.out.println(Thread.currentThread().getName());

    }

}

Callable创建线程

run( )方法没有返回值，使用callable接口即可创建线程也可以获得返回值

//定义Callable接口实现类，重写call（）
public class CallableImpl implements Callable<Object> {

    @Override

    public Object call() throws Exception {

        int c=9;

        return c;

    }

}

//创建Callable实现类对象
public class Test03 {

    public static void main(String[] args) throws InterruptedException, ExecutionException 
{

        CallableImpl callableImpl = new CallableImpl();

        FutureTask<Object> futureTask = new FutureTask<>(callableImpl);//创建FutureTask对象

        Thread thread = new Thread(futureTask);//创建一个新线程

        thread.start();//开启一个新线程

        Object object = futureTask.get();//通过get（）方法获得返回值

        System.out.println(object);

    }

}

线程的六种状态

NEW(新建) RUNNABLE(可运行) BLOCKED(阻塞) WAITING(等待) TIMED_WAITING(定时等待) TERMINAL(终止)

六种状态的相互转换

线程的常用方法

getName

返回线程的名字

1. 如果是使用的第一个方法创建线程，继承Thread创建线程，可以直接使用getName获得线程名
2. 也可以用使用调用Thread的静态方法实现

Thread.currentThread().getName();

sleep

线程睡眠指定的毫秒数，到时后自动唤醒
sleep(int time)

//实现Runnable接口的实现类
public class RunnableImpl02 implements Runnable 
{

    @Override

    public void run() {

        for(int i=0;i<50;i++) {

            System.out.println(Thread.currentThread().getName()+" "+i);

        }

    }

}

//测试类
public class Test04 {

    public static void main(String[] args) {

        RunnableImpl02 impl02 = new 
RunnableImpl02();

        Thread thread = new Thread(impl02);

        thread.start(); 

        for(int i=0;i<50;i++) {

            System.out.println(Thread.currentThread().getName()+"->>"+i);

            if(i==25) {

                try {

                   thread.sleep(1000*3);//睡眠3000毫秒

                } catch (InterruptedException e) {

                    // TODO Auto-generated catch block

                    e.printStackTrace();

                }

            }

        }

    }

}

join

某个线程调用另一个线程的join( )方法；那么当前线程将进入等待状态，直到join( )进来的线程执行完他才能继续。join( )方法也称为加塞方法
thread.join( )
thread.join(int time)

public class RunnableImpl02 implements Runnable //实现了Runnable接口
{

    @Override

    public void run() {

        for(int i=0;i<50;i++) {

            System.out.println(Thread.currentThread().getName()+" "+i);

        }

    }

}

public class Test03 {
    public static void main(String[] args) {

        RunnableImpl02 impl02 = new 
RunnableImpl02();

        Thread thread = new Thread(impl02);

        thread.start(); 

        for(int i=0;i<50;i++) {

            System.out.println(Thread.currentThread().getName()+"->>"+i);

            if(i==25) {

                try {

                    thread.join();//join 此方法必须在其对应start方法之后调用

                } catch (InterruptedException e) {

                    // TODO Auto-generated catch block

                    e.printStackTrace();

                }

            }

        }

    }

}

线程优先级

守护线程

守护线程也称为后台线程
setDaemon(boolean b)，若是true该线程是守护线程，false是用户线程即前台线程，默认为false

public class Test02 {

    public static void main(String[] args) {

        MyRunnable myRunnable = new MyRunnable();

        Thread thread = new Thread(myRunnable);

        thread.setDaemon(true);//设置这个线程为守护线程

        thread.start();

        boolean alive = thread.isAlive();//线程是否在活动

        State state = thread.getState();//线程的状态

        System.out.println(state);

        System.out.println(alive);



        for(int i=0;i<100;i++) {//主线程在running，守护线程也在运行，主线程停止，守护线程也停止

            System.out.println(i);

        }

    }

}

isAlive

测试线程是否处于活动状态。
例子见守护线程

getState

返回线程的状态
例子见守护线程