多线程简介

Java多线程----Thread

java使用Thread类代表线程，所有的线程对象必须是Thread类或者其子类的实例

public class MyThread extends Thread{
        @Override
        public void run() {
            for(int i = 0;i<100;i++){
                System.out.println("---->"+1);
            }
        }
    }
//调用
MyThread thread = new MyThread();
thread.start();
使用这种方法来创建线程类时，多个线程之间无法共享线程类的实例变量

Java多线程----实现Runnable接口

private class RunLearn implements Runnable{
        @Override
        public void run() {
            for (int i = 0; i < 100; i++) {
                System.out.println("---->"+Thread.currentThread().getName()+i);
            }
        }
    }
//调用
RunLearn runLearn = new  RunLearn();
new Thread(runLearn,"线程1--").start();
...
---->线程1--95
---->线程1--96
---->线程1--97
---->线程1--98
---->线程1--99

Java多线程----实现Callable和Future创建线程

Callable接口提供了一个call()方法作为线程的执行体，call()比run()方法功能更加强大。
1、call方法有返回值
2、call方法可以声明抛出异常

FutureTask<Integer>task = new FutureTask<>(new Callable<Integer>() {
    @Override
    public Integer call() throws Exception {
         int sum = 0;
         for (int i = 0; i < 100; i++) {
            sum+=i;
         }
        return sum;
        }
});
//Lambda表达式
FutureTask<Integer>mTask = new FutureTask<>((Callable<Integer>)()->{
    int sum = 0;
    for (int i = 0; i < 100; i++) {
        sum+=i;
     }
    return sum;
});
        
new Thread(task).start();
try {
    System.out.println(task.get()+"<-----");
} catch (Exception e) {
    e.printStackTrace();
} 
System.out.println("haha");

//结果
4950<-----
haha

Java多线程----几个方法

• join()
  json方法让 一个线程等待另一个线程结束

package threadlearn;
public class ThreadMethod extends Thread {
    public ThreadMethod(String name) {
        super(name);
    }
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println("---->"+Thread.currentThread().getName()+i);
        }
    }
    public static void main(String[] args) {
        new ThreadMethod("线程").start();
        for (int i = 0; i < 20; i++) {
            if (i==5) {
                ThreadMethod threadMethod = new ThreadMethod("Join");
                threadMethod.start();
                try {
                    threadMethod.join();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println("---->"+Thread.currentThread().getName()+"=="+i);
        }
    }
}

---->main==0
---->线程0
---->main==1
---->线程1
---->main==2
---->线程2
---->main==3
---->main==4
---->线程3
---->线程4
---->线程5
---->线程6
---->线程7
---->线程8
---->线程9
---->Join0
---->Join1
---->Join2
---->Join3
---->Join4
---->Join5
---->Join6
---->Join7
---->Join8
---->Join9
---->main==5
---->main==6
---->main==7
---->main==8
---->main==9
---->main==10
在主线线程中调用了threadMethod.join(); 这主线程被阻塞直到threadMethod线程执行完毕

• yield
  yield方法让当前线程暂停一下，让系统的线程调度器在重新调度一次。优先级>=当前线程的线程就处于就绪状态获得执行的机会

package threadlearn;
public class YeildLearn extends Thread {
    public YeildLearn(String name) {
        super(name);
    }
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println("---->"+Thread.currentThread().getName()+"--"+i);
            if (i==5) {
                Thread.yield();
            }
        }
    }
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        YeildLearn yLearn1 = new YeildLearn("优先级高");
        yLearn1.setPriority(Thread.MAX_PRIORITY);
        yLearn1.start();
        YeildLearn yLearn2 = new YeildLearn("优先级低");
        yLearn2.setPriority(Thread.MIN_PRIORITY);
        yLearn2.start();
    }
}
---->优先级高--0
---->优先级低--0
---->优先级低--1
---->优先级低--2
---->优先级低--3
---->优先级高--1
---->优先级低--4
---->优先级高--2
---->优先级高--3
---->优先级高--4
---->优先级高--5
---->优先级高--6
---->优先级高--7
---->优先级高--8
---->优先级高--9
---->优先级低--5
---->优先级低--6
---->优先级低--7
---->优先级低--8
---->优先级低--9