Java基础_线程的使用及创建线程的三种方法

 

 

　　线程：线程是操作系统能够进行运算调度的最小单位。它被包含在进程之中，是进程中的实际运作单位。一条线程指的是进程中一个单一顺序的控制流，一个进程中可以并发多个线程，每条线程并行执行不同的任务。

　　进程：进程是计算机中的程序关于某数据集合上的一次运行活动，是系统进行资源分配和调度的基本单位，是操作系统结构的基础。

　　进程与线程的一个简单解释(阮一峰)　　传送门

 

 

　　Java中创建一个线程，方法一：继承Thread类

• 继承Thread
• 重写run方法
• 创建对象，并调用start方法运行

　　(如果直接调用run方法，相当于调用普通方法，并不会启动线程去调用run)

 

public class MyThread extends Thread{
    @Override
    public void run() {   
        for(int i=0;i<1000;i++) {
            System.out.println("MyThread "+i);
        }   
    }
}

 

package com.Gary1;

public class MyThread extends Thread{

    @Override
    public void run() {
        
        for(int i=0;i<1000;i++) {
            System.out.println("MyThread "+i);
        }
        
    }


}

 

　　主方法启动这个线程，直接调用该线程的start()方法，而不是调用run()方法

　　调用线程的run()方法，发现线程并没有并发执行，只是简单的方法调用

　　

 

package com.Gary1;

public class CreateThread {

    public static void main(String[] args) {
        
        MyThread thread = new MyThread();
        
        thread.run();        //错误的，thread.run()指直接调用thread线程里边的run方法
        //thread.start();        //启动线程，run方法自动调用
        
        for(int i=0;i<1000;i++) {
            System.err.println("MainThread "+i);
        }
        
    }
    
}

 

　　调用线程的start()方法，启动线程，可以看到程序中主线程和MyThread线程是并发执行的

　　

 

package com.Gary1;

public class CreateThread {

    public static void main(String[] args) {
        
        MyThread thread = new MyThread();
        
        //thread.run();        //错误的，thread.run()指直接调用thread线程里边的run方法
        thread.start();        //启动线程，run方法自动调用
        
        for(int i=0;i<1000;i++) {
            System.err.println("MainThread "+i);
        }
        
    }
    
}

 

 

　　a)获取（当前）线程名字，设置名字

　　Thread mainThread = Thread.currentThread();

 

    //设置线程名字
    mainThread.setName("Gary");
    //获得线程名字
    System.out.println(mainThread.getName());

 

　　

 

　　b)线程调度规则（线程调度会整体上是遵守下面的规则，但是从单个上来看是随机的）

　　　　分时调度（平均分配）：10个线程执行100毫秒CPU，每个线程平均分配10毫秒的CPU

　　　　抢占式调度（按照优先级）（Java使用的调度规则）：优先级高的，有更高的几率被CPU所执行

　　　　获得线程优先级：thread.getPriority()

    MyThread thread = new MyThread();
    //获得线程优先级
    System.out.println(thread.getPriority());

 

　　

 

 

　　c)设置优先级为1，mainThread.setPriority()

    mainThread.setPriority(1);

 

 　　d)线程休眠，让当前线程休眠（单位毫秒）

    Thread.sleep();

 

 　　e)join 把某个线程加入到当前线程中(Main()方法中为主线程，)

    t1.join();

 

　　 f)设置守护线程setDaemon(true)

 　　如果程序中只剩下守护线程在运行，那么程序会停止

    t2.setDaemon(true);    

 

　　g)线程中断

　　　　stop()启用(被弃用)

　　　　interrupt() 让线程自己抛出异常，让线程自己可以处理被终止的时候做一些事情

    t1.stop();
    t1.interrupt();

 

 

　　Java中创建一个线程，方法二：实现Runnable接口

　　　　a)实现Runnable接口

　　　　b)实现run方法

　　　　c)创建当前类的对象和Thread的对象，并使用thread对象启动线程

 

　　　　a)获取当前线程的名字

　　　　　　　　Thread.currentThread().getName()

　　　　　　　　设置名字通过Thread对象

　　　　b)构造方法

　　　　　　　　Thread t = new Thread(Runnable target);

　　　　　　　　Thread t = new Thread(Runnable target,String name);

package com.Gary1;

public class MyThread2 implements Runnable{

    @Override
    public void run() {
        
        for(int i=0;i<100;i++) {
            //获得当前线程
            Thread t = Thread.currentThread();
            
            System.out.println(t.getName()+i);
        }
        
    }
}

 

package com.Gary1;

public class CreateThread2 {

    public static void main(String[] args) {
        
        //创建当前类的对象和Thread的对象
        MyThread2 t = new MyThread2();
        //并使用thread对象启动线程
        Thread t1 = new Thread(t);
        t1.start();
        
        Thread t2 = new Thread(t,"线程2");
        t2.start();//调用了同一个Thread2的run()方法
        
    }
    
}

 

　　方式二的好处：

　　　　可以避免单继承带来的局限性（实现了接口后，可以继承一个别的类）

　　　　可以很好的处理两个线程共享一个资源的情况

 

　　Java中创建一个线程，方法三：使用匿名内部类

　　　　a)new Runnable(){}

　　　　b)new Thread(){}

　　

 

package com.Gary1;

public class CreateThread3 {

    public static void main(String[] args) {
        //匿名内部类
        //适用于线程只在这里实现以此
        Runnable r = new Runnable() {

            @Override
            public void run() {
                for(int i=0;i<100;i++) {
                    System.out.println(Thread.currentThread().getName()+":"+i);
                }
            }

        };
        
        //    Thread t = new Thread(r,"匿名内部类线程");
        //    t.start();
        
        new Thread(r,"匿名内部类线程").start();
        
    }
}