1.实现多线程的两种方式：

（1）继承Thread类； （2）实现Runnable接口

//进程：每个进程都有独立的代码和数据空间（进程上下文），进程间的切换开销比较大，一个进程包含1-n个线程
//线程：同一类线程共享代码和数据空间，每个线程拥有独立的运行栈和程序计数器，线程切换开销小
//多进程是指操作系统能同时运行多个任务（程序）。
//多线程是指在同一程序中有多个顺序流在执行。

//实现多线程的两种方式：（1）继承Thread类； （2）实现Runnable接口


public class ThreadTest {

        public static void main(String[] args)
        {
                MyThread t1 = new MyThread("t1");
                MyThread t2 = new MyThread("t2");
                t1.start();
                t2.start();
               
        }
}


class MyThread extends Thread
{
        private String name;
        public MyThread(String name)
        {
                this.name = name;
        }
        @Override
        public void run()
        {
                for(int i = 0; i < 5 ; i++)
                {
                        System.out.println(name + ":" + i);
                        try {
                                sleep(1000);
                        } catch (InterruptedException e) {
                                // TODO Auto-generated catch block
                                e.printStackTrace();
                        }
                }
        }
       
}
//实现多线程的两种方式:(1)继承Tread类； （2）实现Runnable接口
//如果一个类继承Thread，则不适合资源共享。但是如果实现了Runable接口的话，则很容易的实现资源共享。
public class ThreadTest2 {

        public static void main(String[] args)
        {
                MyThread2 t1 = new MyThread2();
                new Thread(t1).start();
                new Thread(t1).start();
                new Thread(t1).start();
        }
}


class MyThread2 implements Runnable
{
        private int tickets = 10;
        @Override
        public synchronized void run()
        {
                for(int i = 0; i < 10; i++ )
                {
                        if(this.tickets > 0)
                        {
                                System.out.println("买票" + this.tickets-- );
                        }
                }
        }
       
}
2. 常用函数

（1）获取和设置线程的名称

获取：String getName( );

设置：Thread(Runnable r, String name); 或 thread.setName("name");

（2）判断一条线程的存活状态

thread.isAlive();

一条线程的寿命起始于start()方法，终止于离开run方法.

（3）获取一条线程的执行状态

thread.getState();

线程的执行状态有：new; runnable; blocked; waiting; time_waiting; terminated

（4）获取和设置线程的优先级

获取： int getPriority();  

设置： thread.setPriority(int priority);

使用setPriority()会影响 应用程序的可移植性

（5）获取和设置线程的守护线程状态

一条守护线程扮演非守护线程辅助者的角色；会在应用程序最后一条非守护线程消失后自动死亡，因此应用程序才能终止。

获取：Thread的 boolean isDaemon( )；

设置：Thread 的 void setDaemon（boolean isDaemon);

（6）启动线程

调用Thread 的void start() 方法启动与该对象关联的线程。

（7）中断线程

public boolean isInterrupted()

public void interrupt()

public static boolean interrupted()

isInterrupted是一个实例方法，主要用于判断当前线程对象的中断标志位是否被标记了，如果被标记了则返回true表示当前已经被中断，否则返回false。调用isInterrupted并不会清除线程对象的中断标识位。

interrupt是一个实例方法，该方法用于设置当前线程对象的中断标识位。

interrupted是一个静态的方法，用于返回当前线程是否被中断。该方法用于判断当前线程是否被中断，并且该方法调用结束的时候会清空中断标识位。

（8）中断线程

void join();
void join(long millis); // 等待该线程终止的最长时间为millis毫秒
void join(long millis, int nanos); // 等待该线程终止的最长时间为millis毫秒+nanos纳秒

使用Thread的join()方法，join()方法会阻塞主线程继续向下执行，直到子线程执行完毕。如果不采用join()方法的话，会先执行完main线程，子线程继续执行。

（9）线程睡眠

Thread类声明了一对静态方法使线程睡眠（暂时性地停止执行）

void sleep(loong millis);

void sleep(long millis, int nanos);
---------------------
【转载】
作者：zhm1563550235
原文：https://blog.csdn.net/zhm1563550235/article/details/84196628