java线程基础

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.后台线程

1. 后台执行的线程，也可称之为守护线程。
2. JVM垃圾回回收线程就是典型的守护线程。
3. 后台线程为其他线程服务，当所有非后台线程结束时后台线程才结束。
4. 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();
    }
}