线程的生命周期
线程是一个动态执行的过程，它也有一个从生产到死亡的过程
新建状态：
使用 new 关键词和 Thread 类或者子类建立一个线程对象后，该线程就会保持这个状态直到程序 start（）这个线程
就绪状态：
当线程对象调用了 start（）方法之后，该线程就进入了就绪状态。
运行状态：
如果就绪状态的线程获取 CPU 资源，就可以执行 run（）。
阻塞状态：
如果一个线程执行了 sleep（睡眠）、suspend（挂起）等方法，失去所占用资源之后，该线程就从运行状态进入阻塞状态。
死亡状态：
一个运行状态的线程完成任务或者发生终止条件时，该线程就切换到终止状态了。
通过继承 Thread 类的方式实现多线程
方式一：
继承 Thread 类
定义一个 MyThread 来继承 Thread 类
在 MyThread 类中重写 run（）
创建 MyThread 类的对象
启动线程
实例：
public class Test { public static void main(String[] args) { MyThread my1=new MyThread(); MyThread my2=new MyThread(); my1.start(); my2.start(); public class MyThread extends Thread{
@Override public void run() { for (int i = 0; i <100 ; i++) { System.out.println(i); } }
复制代码
通过实现 Runnable 接口实现多线程
方式二：
定义一个类 MyRunnable 实现 Runnable 接口
在 MyRunnable 类中重写 run（）方法
创建 MyRunnable 类的对象
创建 Thread 类的对象，把 MyRunnable 对象作为构造方法的参数
启动线程
实例：
package Runnable接口;
public class Test { public static void main(String[] args) { //创建MyRunnable类的对象 MyRunnable my=new MyRunnable();
//创建Thread类的对象，把MyRunnable对象作为构造方法的参数 //Thread(Runnable target)// Thread t1=new Thread(my);// Thread t2=new Thread(my);
//Thread(Runnable target,String name) Thread t1=new Thread(my,"yyy"); Thread t2=new Thread(my,"uuu");
t1.start(); t2.start(); }}
package Runnable接口;
public class MyRunnable implements Runnable{ @Override public void run() { for (int i = 0; i <10 ; i++) { System.out.println(Thread.currentThread().getName()+","+i); } }}
复制代码
设置和获取线程名称
void setName(String name);将此线程的名称更改为等于参数 name String getName();返回此线程的名称
实例：
package 继承Thread类;
public class Test { public static void main(String[] args) { //Thread(String name) MyThread my1=new MyThread("yyy");//MyThread中没有带参构造方法，需要创建 MyThread my2=new MyThread("uuu");
//void setName(String name);将此线程的名称更改为等于参数name my1.setName("yyy"); my2.setName("uuu");
my1.start(); //同时执行，相当于先启动线程，再调用了run() my2.start();
//static Thread currentThread()返回当前正在执行的线程对象的引用 System.out.println(Thread.currentThread().getName()); }}
package 继承Thread类;
public class MyThread extends Thread{
public MyThread(){}
public MyThread(String name){ super(name); }
@Override public void run() { for (int i = 0; i <100 ; i++) { System.out.println(getName()+","+i); //String getName();返回此线程的名称 } }}
复制代码
线程的优先级
Java 线程的优先级是一个整数，取值范围为 1 （Thread.MIN_PRIORITY ） - 1（Thread.MAX_PRIORITY ）。默认情况下，每一个线程都会分配一个优先级 NORM_PRIORITY（5）。
线程调度（两种调度模型）
Thread 类中设置和获取线程优先级的方法：
public final void setPriority(int newPriority);更改此线程的优先级
public final int getPriority();返回此线程的优先级
实例：
package 线程的优先级;
public class Test { public static void main(String[] args) { ThreadPriority tp1=new ThreadPriority(); ThreadPriority tp2=new ThreadPriority(); ThreadPriority tp3=new ThreadPriority();
tp1.setName("yyy"); tp2.setName("uuu"); tp3.setName("ppp");
//public final int getPriority();返回此线程的优先级 System.out.println(tp1.getPriority());//默认优先级为5 System.out.println(tp2.getPriority()); System.out.println(tp3.getPriority());
//public final void setPriority(int newPriority);更改此线程的优先级 //tp1.setPriority(10000);//IllegalArgumentException 非法参数异常 System.out.println(Thread.MAX_PRIORITY); System.out.println(Thread.MIN_PRIORITY); System.out.println(Thread.NORM_PRIORITY);
//设置优先级, 线程优先级高仅仅表示它获取cpu时间片的几率高 tp1.setPriority(10); tp2.setPriority(5); tp3.setPriority(1);
tp1.start(); tp2.start(); tp3.start(); }}
复制代码
线程控制
static void sleep(long millis);使当前正在执行的线程停留（暂停执行）指定的毫秒数
void join();等待这个线程死亡
void setDaemon（boolean on）；将此线程标记为守护线程，当运行的线程都是守护线程时，；
实例：
package 线程控制;
public class ThreadSleep extends Thread{ @Override public void run() { for (int i = 0; i <20 ; i++) { System.out.println(getName()+","+i); try { Thread.sleep(1000);//每输出一次，线程休眠一秒 } catch (InterruptedException e) { e.printStackTrace(); } } }}
package 线程控制;
public class ThreadJoinTest { public static void main(String[] args) { ThreadJoin tj1=new ThreadJoin(); ThreadJoin tj2=new ThreadJoin(); ThreadJoin tj3=new ThreadJoin();
tj1.setName("yyy"); tj2.setName("uuu"); tj3.setName("ppp");
tj1.start(); try { tj1.join();//捕获异常 } catch (InterruptedException e) { e.printStackTrace(); } tj2.start(); tj3.start(); }}
package 线程控制;
public class ThreadDaemonTest { public static void main(String[] args) { ThreadDaemon td1=new ThreadDaemon(); ThreadDaemon td2=new ThreadDaemon();
td1.setName("yyy"); td2.setName("uuu");
//设置主线程为ppp Thread.currentThread().setName("ppp");
//设置守护线程 td1.setDaemon(true); td2.setDaemon(true);
td1.start(); td2.start();
for (int i = 0; i <10 ; i++) { System.out.println(Thread.currentThread().getName()+","+i); } }}
复制代码
评论