关于java线程的学习

线程的概念以及他和进程的区别

线程是cpu资源分配的最小单元，进程是程序执行相关资源（CPU、内存、磁盘等） 的最小单元，进程之间相互独立，有自己的内存空间，进程包含一个或着多个线程线程需要的资源更少，可以看做是一种轻量级的进程，线程会共享进程中的内存，线程也有独立的空间（栈、程序计数器），线程相互通信更加方便

线程的实现

Java几种实现线程的方式

1. 继承Thread类

2. 实现Runnable接口

3. 实现Callable接口

4. 使用线程池

 继承Thread类

/**
 * 自定义线程类
 */
class MyThread extends Thread{

    /**
     * 执行指令
     */
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName() +"执行了" + i);
        }
    }
}

public class ThreadDemo {

    public static void main(String[] args) {
        //创建线程对象
        MyThread myThread = new MyThread();
        //启动线程
        myThread.start();
        //主线程执行
        for (int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName() +"执行了" + i);
        }
    }
}

实现Runnable接口

/**
 * 实现Runnable接口的类
 */
class MyRunnable implements Runnable{

    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName() + "--" + i);
        }
    }
}
public class RunnableDemo {
    public static void main(String[] args) {
        //创建Runnable对象，传入Thread对象
        MyRunnable myRunnable = new MyRunnable();
        Thread thread = new Thread(myRunnable);
        //启动线程
        thread.start();
}
}

实现Callable接口

/**
 * 实现Callable接口
 */
class MyCallable implements Callable<Long> {

    @Override
    public Long call() throws Exception {
        //模拟复杂运算
        long sum = 0;
        for(long i = 0;i < 1000000000L;i++){
            sum += i;
        }
        return sum;
    }
}
public class CallableDemo {

    public static void main(String[] args) {
        //创建Callable对象，传入FutureTask对象
        FutureTask<Long> task = new FutureTask<>(new MyCallable());
        //创建FutureTask对象到Thread对象中
        Thread thread = new Thread(task);
        //启动线程
        thread.start();
        System.out.println("-----等待结果-----");
        //获得返回值
        try {
            System.out.println(task.get());
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}

各自的好处

继承Thread类就自己写run方法，而实现Runable接口则run方法被写死，回返了代码，从这个方面来说，Runnable是要更好的，而实现Callable接口可以得到一个返回值

线程的run和start的区别

• run没有启动新线程，在主线程中执行

• start才能启动新线程

 线程常用的一些方法

方法	效果
start()	启动
stop()	停止
getName	获得线程名字
setName	设置线程名字
sleep	睡眠，单位是毫秒
setPriority	设置优先级
join（）	线程的加入（合并），让其他的执行完，再执行自己的指令

 最后，用线程做个小游戏

多线程模拟龟兔赛跑：

乌龟和兔子进行1000米赛跑，兔子前进5米，乌龟只能前进1米。

但兔子每20米要休息500毫秒，而乌龟是每100米休息500毫秒。

谁先到终点就结束程序，并显示获胜

public class task4 {
    static Thread thread1=null;
    static Thread thread2=null;
    public static void main(String[] args) {
       thread1  = new Thread(()->{
           //兔子
          for (int i=0;i<=1000;i+=5){
              if (i%20 == 0){
                  try {
                      Thread.sleep(500);
                  } catch (InterruptedException e) {
                      e.printStackTrace();
                  }
              }
              System.out.println("兔子跑到了"+i+"米");
              if (i==1000){
                  System.exit(0);}
          }
       });
       thread2 = new Thread(()->{
          //乌龟
          for (int i=0;i<=1000;i++){
              if (i%100==0){
                  try {
                      Thread.sleep(500);
                  } catch (InterruptedException e) {
                      e.printStackTrace();
                  }
              }
              System.out.println("乌龟跑到了"+i+"米");
              if (i==1000){
              System.exit(0);}
          }
       });
       thread1.start();
       thread2.start();
    }
}