1.通过继承Thread类创建线程
public class Thread extends Object implements Runnabel
- Thread类已经实现了Runnable接口
- 继承Tread的类只需重写run方法
- Thread类已经定义了final类型的getName和setName方法
- 启动线程应调用start方法而不是run方法
- 一个线程对象只能调用一次start方法，否则会抛IllegalThreadStartException错误
package com.gyp.thread.start;
public class Test1 extends Thread{
private String name;
public Test1(){
}
public Test1(String name){
setName(name);
}
public void run(){
for(int i=0;i<10;i++){
System.out.println("当前运行的线程："+getName()+",i="+i);
}
}
public static void main(String[] args){
Test1 t1 = new Test1();
Test1 t2 = new Test1("线程2");
t1.start();
t2.start();
//受单继承的影响
// t2.start();
}
}
2.通过实现Runnable接口创建线程
public interface Runnable{ public abstract void run(); }
- Runnable只提供了run方法
- Runnable对线程没有任何支持，在获得线程实例后必须通过Thread类的构造函数来实现
package com.gyp.thread.start;
public class Test2 implements Runnable {
private String name;
//实现接口的类要自己定义方法
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Test2(){
}
public Test2(String name){
setName(name);
}
public void run(){
for(int i=0;i<10;i++){
System.out.println("当前运行的线程:"+getName()+",i="+i);
}
}
public static void main(String[] args){
Test2 r1 = new Test2();
Test2 r2 = new Test2("线程2");
Thread t1 = new Thread(r1);
Thread t2 = new Thread(r2);
t1.start();
t2.start();
}
}
2.5继承Thread类和实现Runnable接口的区别
- 一般选择后者
- 避免单继承带来的局限性
- 适合多个相同程序代码的线程区处理同一资源的情况。
- 前者处理同一资源可用静态变量。
3.主线程-main()
- 主线程是自动创建的，是产生应用程序所有其他线程的线程。
- 程序中只要还有其他非守护线程没有结束，主线程就不会结束，即使主线程已执行完或者调用了retuen。
- 一个java程序最少有两个线程，一个是main,优先级5，一个是JVM垃圾收集线程
package com.gyp.thread.start;
public class Test3 implements Runnable {
public void run(){
for(int i=0; i<10; i++){
System.out.println("当前运行线程："+Thread.currentThread()+", i="+i);
}
}
public static void main(String[] args){
//获取当前对象的线程引用
Thread mi = Thread.currentThread();
System.out.println("线程的信息："+mi);
System.out.println("线程的名字："+mi.getName());
mi.setName("主线程");
System.out.println("线程的名字："+mi.getName());
Test3 r = new Test3();
Thread t = new Thread(r);
t.start();
t.run(); //直接调用run方法
}
}
4.线程的加入join()
使当前运行的线程停下来，等待调用join的线程执行，可设最长等待时间，也可不设等他执行完。
package com.gyp.thread.start;
import java.util.Date;
/**
* @author gyp19
* 线程的加入join()
* 等待调用的线程终止
*/
class ThreadTest4 implements Runnable{
public void run(){
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
for(int i=0;i<5;i++){
System.out.println("当前运行的线程："+Thread.currentThread().getName()+" ,i="+i+"时间:"+new Date());
}
}
}
public class Test4 {
public static void main(String[] arge){
ThreadTest4 r = new ThreadTest4();
Thread t = new Thread(r,"线程一");
Thread mi = Thread.currentThread();//获得主线程的引用
t.start();
for(int i=0;i<10;i++){
if(i==5){
try {
t.join(3000); //最大等待时间3s
// mi.join(3000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println("main="+i+"，时间："+new Date());
}
}
}
5.线程的唤醒 interrupt()
线程从休眠的组赛状态(sleep)转化为运行状态。
package com.gyp.thread.start;
import java.util.Date;
class ThreadTest5 implements Runnable{
public void run(){
System.out.println("线程开始的时间："+new Date());
for(int i=0;i<5;i++){
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
// e.printStackTrace();
System.out.println("线程被唤醒啦啦啦");
}
System.out.println(Thread.currentThread().getName()+"的第"+i+1+"秒"+", 时间："+new Date());
}
System.out.println("线程的结束时间："+new Date());
}
}
public class Test5 {
public static void main(String[] args){
ThreadTest5 r = new ThreadTest5();
Thread t = new Thread(r,"线程一");
t.start();
try {
Thread.sleep(2000);//使用t.sleep(2000);的效果也是一样一样的
} catch (InterruptedException e) {
e.printStackTrace();
}
t.interrupt(); //唤醒线程
}
}
6.后台线程
- 后台执行的线程，也可称之为守护线程。
- JVM垃圾回回收线程就是典型的守护线程。
- 后台线程为其他线程服务，当所有非后台线程结束时后台线程才结束。
- main()是一个非后台线程。
setDaemon(true) : 设置后台线程
isDaemon() : 判断是否为后台线程，是则true
package com.gyp.thread.start;
public class Test6 implements Runnable{
public void run(){
int i=0;
while(true){
System.out.println("i="+(i++));
}
}
public static void main(String[] args){
Test6 r = new Test6();
Thread t = new Thread(r,"线程一");
t.setDaemon(true);
if(t.isDaemon()){
t.start();
}
System.out.println("say something");
}
}
7.线程的礼让
1.当前正在运行的线程推出运行状态，暂时让其他线程执行。
2.不能让给指定的线程，一般优先级高的线程会先当到运行资源。
3.sleep和yield的区别
- sleep让出运行权时不考虑别的线程的优先级。
- sleep转到堵塞状态，yield转到就绪状态。
- sleep会抛出异常。
- slepp有着更好的移植性，不能依靠yield方法提高程序的并发性。
yield() : 调用礼让
package com.gyp.thread.start;
class ThreadDemo1 implements Runnable{
public void run(){
for(int i=0;i<10;i++){
System.out.println("礼让->"+Thread.currentThread().getName()+":i="+i);
//线程的礼让
Thread.currentThread().yield();
}
}
}
class ThreadDemo2 implements Runnable{
public void run(){
for(int i=0;i<10;i++){
System.out.println(Thread.currentThread().getName()+":i="+i);
}
}
}
public class Test7 {
public static void main(String[] args){
Runnable r1 = new ThreadDemo1();
Runnable r2 = new ThreadDemo2();
Thread t1 = new Thread(r1,"Thread-one");
Thread t2 = new Thread(r2,"线程二");
t1.start();
t2.start();
}
}
