多线程的创建

线程和进程的区别

• 进程：是指一个内存中运行的应用程序，每个进程都有一个独立的内存空间，一个应用程序可以同时运行多个进程；进程也是程序的一次执行过程，是系统运行程序的基本单位；系统运行一个程序即是一个进程从创建、运行、到消亡的过程。

• 线程：进程内部的一个独立单元；一个进程可以同时并发的运行多个线程，可以理解为一个进程便相当于一个单cpu操作系统，而线程便是这个系统中运行的多个任务。

 创建线程的三种方式：

1.通过继承thread,重写run方法，没有返回值。

package com.hp.demo4;

public class Demo1 extends Thread{
    private static int num=1;
    private static Object obj=new Object();
    @Override
    public void run() {
while (true){
    try {
        sleep(500);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    synchronized (obj){
        if (num>100){
            System.exit(0);
        }else {
            System.out.println(Thread.currentThread().getName()+"号线程："+num);
            num++;
        }
    }
}
    }

    public static void main(String[] args) {
        Demo1 d1=new Demo1();
        d1.start();
        Demo1 d2=new Demo1();
        d2.start();
    }
}

2.通过实现runnable接口，实现run方法，没有返回值。

package com.hp.demo4;

public class Demo2 implements Runnable{
    private static int sum=30;
    private static Object obj=new Object();
    public static void sleep(){
        Thread thread=new Thread();
        try {
            thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    @Override
    public void run() {
        while(true){
            sleep();
            synchronized (obj){
                if (sum>0){
                    System.out.println(Thread.currentThread().getName()+"号："+sum);
                    sum--;
                }else {
                    System.exit(0);
                }
            }
        }
    }
    public static void main(String[] args) {
        Demo2 d1=new Demo2();
        Thread t=new Thread(d1);
        t.start();
        Demo2 d2=new Demo2();
        Thread t2=new Thread(d2);
        t2.start();
        Demo2 d3=new Demo2();
        Thread t3=new Thread(d2);
        t3.start();
    }
}

3.callable<T> 实现call方法，有返回值。

package com.hp.demo1;
import java.util.concurrent.*;

public class CallableDemo implements Callable<Integer> {
    private int i;

    public CallableDemo(int i) {
        this.i = i;
    }

    @Override
    public Integer call() throws Exception {
        int sum=0;
        for (int j = 0; j < i; j++) {
            sum+=i;
        }
        System.out.println(Thread.currentThread().getName()+"i="+i+"sum"+sum);
        return sum;
    }

    public static void main(String[] args) {
        CallableDemo callableDemo =new CallableDemo(100);
        FutureTask futureTask = new FutureTask(callableDemo);
        CallableDemo callableDemo1 =new CallableDemo(110);
        FutureTask futureTask1 = new FutureTask(callableDemo1);
        ExecutorService executorService = Executors.newSingleThreadExecutor();
        executorService.submit(futureTask);
        executorService.submit(futureTask1);
        executorService.shutdown();

        try {
            int sum=(int)futureTask.get();
            System.out.println(sum);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }

    }
}

线程中 run和start的区别

run()方法:在本线程内调用该Runnable对象的run()方法，可以重复多次调用； start()方法:启动一个线程，调用该Runnable对象的run()方法，不能多次启动一个线程。