Java-----多线程基础

1、进程

          描述：

              正在运行的程序，是一个程序的运行状态和和资源占用（CPU，内存）的描述。

          特点：

                 1、独立性：不同的进程之间是独立的，相互之间资源不共享

                 2、动态性：进程在系统中不是静止不动的，而是在系统中一直活动的

                 3、并发性：：多个进程可以在单个处理器上同时进行，且互不影响

2、线程

          描述：线程就是一条执行路径。是进程的组成部分，一个进程可以有多个线程，每个线程去处理一个特定的子任务。

          特点：线程的执行是抢占式的，多个线程在同一个进程中可以并发执行，其实就是CPU快速的在不同的线程之间切换，也就是说，当前运行的线程在任何时候都有可能被挂起，以便另外一个线程可以运行。

             当一个线程获得cpu时间片就会执行此线程任务，当cup时间片时间使用完，不管当前线程任务是否执行完，都会进入等待状态，等待下一次得到cpu时间片，继续执行未完成任务。（cpu时间片长短由cpu决定）

          一个进程里面至少包含一个或者多个线程。

3、进程和线程之间的区别

                     a.一个程序运行后至少有一个进程
                     b.一个进程可以包含多个线程，但是至少需要有一个线程，否则这个进程是没有意义的
                     c.进程间不能共享资源，但线程之间可以
                     d.系统创建进程需要为该进程重新分配系统资源，而创建线程则容易的多，因此使用线程实现多任务并发比多进程的效率高

 4、多线程的创建方式                   

                 1 继承Thread类

public class MyThread extends Thread{
    @Override
    public void run() {
        //打印线程名称
        System.out.println(Thread.currentThread().getName()+"----启动");
    }
}


//测试类
public class MyThreadTest {
    public static void main(String[] args) {
        MyThread myThread1 = new MyThread();
        MyThread myThread2 = new MyThread();
        Thread thread1 = new Thread(myThread1,"线程1");
        Thread thread2 = new Thread(myThread1,"线程2");
        thread1.start();
        thread2.start();
    }
}

//结果
线程1-----启动
线程2-----启动

 

                 2 实现Runnable接口

public class MyRunnable implements Runnable {
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"------启动");
    }
}
//测试类
public class MyRunnableTest {
    public static void main(String[] args) {
        new Thread(new MyRunnable(), "线程1").start();
        new Thread(new MyRunnable(), "线程2").start();
    }
}
//结果
线程1-----启动
线程2-----启动

                 3 实现Callable接口（有返回值）

public class MyCallable implements Callable<Integer>{

	@Override
	public Integer call() throws Exception {
		int sum=0;
		for(int i=1;i<=100;i++){
			Thread.sleep(100);
			sum+=i;
		}
		return sum;
	}

}
//测试类
public static void main(String[] args) throws Exception{
		//1创建Mycallable对象(可调用的)
		MyCallable callable=new MyCallable();
		//2创建一个任务实现Runable接口
		FutureTask<Integer> task=new FutureTask<Integer>(callable);
		//3创建线程对象
		Thread thread=new Thread(task);
		//4启动
		thread.start();
		//5获取返回值
		Integer sum=task.get();//会等待子线程执行完毕，返回结果
		System.out.println(sum);
		
	}
//结果
5050

4、线程的常用方法

//使得当前正在执行的线程休眠一段时间，释放时间片，导致线程进入阻塞状态
Thread.sleep(5000);

 

//优先级范围1~10，默认为5，对应的数值越大，说明优先级越高，这个方法的设置一定要在start之前
setPriority();

     

//合并线程
//	在执行原来线程的过程中，如果遇到了合并线程，则优先执行合并进来的线程，执行完合并进来的线程后，再 
//    回到原来的任务中，继续执行原来的线程。
//	特点：
//		a.线程合并,当前线程一定会释放cpu时间片,cpu会将时间片分给要Join的线程
//		b.哪个线程需要合并就在当前线程中,添加要合并的线程
//		c.join之前,一定要将线程处于准备状态start
join()

//后台线程
//线程分为前台(用户)线程和后台(守护)线程。
//	后台线程：隐藏起来一直在默默运行的线程，直到进程结束，又被称为守护线程，JVM的垃圾回收线程就是
//典型的后台线程。特征：如果所有的前台线程都死亡，后台线程会自动死亡。
//	前台线程:默认的线程都是前台线程，如果前台不执行完毕，程序不会退出。

//线程让步
//	可以让当前正在执行的线程暂停，但它不会阻塞该线程，他只是将该线程转入就绪状态，完全可能出现的情
//况是：当某个线程调用了yield方法暂停之后，线程调度器又将其调度出来重新执行。
//	实际上，当某个线程调用了yield方法暂停之后，只有优先级与当前线程相同，或者优先级比当前线程更高
//的就绪状态的线程才会获得执行的机会。

程序在等待过程中，可以使用interrupt方法打断。

5、线程生命周期