Java--线程--Thread

/**线程基本知识：
 * 1.程序=数据结构+算法
 * 2.进程：正在运行的程序
 * 3.线程：进程中系统进行调度的最小执行单元
 * 进程和线程的关系：
 *     a)1个进程可以由1个（单线程）或多个线程（多线程）组成
 *     b)1线程存在于进程当中
 *     c)线程必须依赖进程来运行
 * 如何使用线程：
 *     a)Thread类 全限定名：java.lang.Thread
 *       public class Thread implements Runnable
 *     b)Thread类基本成员：
 *       private String name;  //线程名称
 *        ...
 *       Thread();
 *       Thread.currentThread();
 */

单线程测试

/**单线程测试：
 * Java程序主线程--单线程
 *     线程默认名称： main
 *     线程     id:    1
 *     线程默认优先级：5
 */
public class SingleThreadTest {

    //主线程的入口方法
    public static void main(String[] args) {

        //静态调用，获取当前线程对象
        Thread t = Thread.currentThread();
        t.setName("Java主线程");
        System.out.println("当前线程名称："+t.getName());
        System.out.println("当前线程id："+t.getId());
        System.out.println("当前线程优先级："+t.getPriority());
    }
}

运行结果：

当前线程名称：Java主线程
当前线程id：1
当前线程优先级：5

多线程方法一

package com.thread;

/**多线程方法1：
 * 继承Thread类：
 *     定义子类继承Thread类
 *     重写run方法
 *     创建子类实例
 *     调用start方法启动线程
 */

/**
 * 任务1：打印26个字母--由main主线程完成
 * 任务2：打印数字0~99--由SubThread线程完成
 * 两个线程协助完成该程序的任务：多线程多任务
 */
//定义一个子线程
class SubThread extends Thread{

    //难点
    //不可以：SubThread myThread = new SubThread();
    //        myThread.run();
    //正确：  myThread.start();
    //执行时机：操作系统调度算法分配CPU等资源给该线程时，就调用执行方法

    @Override
    public void run() {
        System.out.println("子线程开始：");
        for (int i = 0; i < 100; i++) {
            System.out.println("子线程："+i);
        }
        System.out.println("子线程结束。");
    }
}
public class TwoThreadTest {
    public static void main(String[] args) {

        System.out.println("主线程开始：");
        ;
        ;
        //创建子线程对象
        SubThread myThread = new SubThread();
        //正确使用线程的方式
        myThread.start();
        //错误使用线程的方式
        //myThread.run();
        ;
        ;
        for(int i = 0;i < 26;i ++)
            System.out.println((char)(i+65));

        System.out.println("主线程结束。");

    }
}

多线程方法二

package com.thread;

/**多线程方法2：
 * 实现Runnable接口
 *     创建实现类
 *     创建实例
 *     把该实例作为参数构建Thread对象
 *     调用start方法启动线程
 */
class MyThread implements Runnable{
    @Override
    public void run() {
        System.out.println("MyThread线程开始：");
        for (int i = 1; i < 101 ; i++) {
            System.out.println("线程id:"+Thread.currentThread().getId()+"，i="+i);
        }
    }
}
public class RunnableTest {
    public static void main(String[] args) {
        System.out.println("主线程开始：");
        for (int i = 0; i < 26; i++) {
            System.out.println((char)(i+65));
        }

        Runnable runnableImpl = new MyThread();
        Thread t1 = new Thread(runnableImpl);
        t1.start();

    }
}

多线程方法三

package com.thread;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

/**多线程方法3：
 * //1.创建实现Callable接口的实现类的实例
 *         CallablePrint cp = new CallablePrint();
 * //2.将该实例交给FutureTask构造器创建FutureTask实例
 *         FutureTask<Integer> ft = new FutureTask<Integer>(cp);
 * //3.将FutureTask实例交给Thread构造器创建Thread实例
 *         Thread thread = new Thread(ft);
 *
 * //4.启动线程
 *         thread.start();
 * //5.接收call方法返回值
 *         ft.get();
 */
public class CallableTest implements Callable<Integer> {
    public static void main(String[] args) throws ExecutionException, InterruptedException {

        //创建实现接口Callable类的实例
        CallableTest callabletest = new CallableTest();
        //通过FutureTask构造器由Callable实现类实例创建FutureTask类实例
        FutureTask<Integer> futuretask = new FutureTask<Integer>(callabletest);
        //通过Thread构造器由FutureTask实例创建Thread实例
        Thread thread = new Thread(futuretask);
        thread.start();
        int sum = futuretask.get();
        System.out.println("结果为："+sum);
    }

    @Override
    public Integer call() throws Exception {

        int sum = 0;
        for (int i = 1; i <= 100; i++) {
            sum += i;
        }
        return sum;
    }
}