JAVA基础（26）-Java多线程基础，

来源： javaer 分享于 2024-05-22 点击 30295 次点评：219

JAVA基础（26）-Java多线程基础，

一、进程与线程

进程

线程

进程与线程区别

线程应用

线程的创建方式(3种)

同步锁

线程池

一、进程与线程

进程

是一个运行中的程序的实例。
特点：
(1)是一个实体，都有自己独立的地址空间，分为文本区域，数据区域和堆栈。文本区域用来存储编写的程序的代码，数据区域用来存储运行时所需要的数据(动态分配的内存)，堆栈用来存储运行时涉及到的指令和本地变量
(2)是一个"运行中的程序"，程序本身是一个没有生命的实体，只有当处理器赋予它生命时，它才能称之为一个活动的实体，即进程。进程是操作系统级别的基本单元。
通俗点说：进程就是操作系统运行的一个任务(一个应用程序运行时，就对应一个进程)

线程

1、进程中所包含的一个或多个执行单元，这个执行单元称为线程，一个线程就是进程中的一个顺序执行流
2、进程拥有一个私有的虚拟空间，该空间仅能被它所包含的线程访问，及同一个进程中的多个线程共享一块内存空间和一组系统资源
3、线程只能归属于一个进程并且只能访问该进程所有的资源
4、线程本身也有一个供程序执行的堆栈，在线程切换时，负荷小，因此线程也被称为轻负荷进程

进程与线程区别

进程是操作系统运行的一个任务，线程是进程中运行的一个任务
进程是资源分配的最小单位（相互独立），线程是程序执行的最小单位（cpu调度的基本单元）
进程有自己的独立地址空间，每启动一个进程，系统就会为它分配地址空间，建立数据表来维护代码段、堆栈段和数据段、这种操作非常昂贵。进程之间的通信需要以IPC进行
线程是轻量级的进程，同一个进程中可以包含多个线程。多线程共享进程中的数据，使用相同的地址空间，因此，线程之间的通信更方便，CPU切换（或创建）一个线程的开销远比进程要小很多
一个进程结束，期内的所有线程都结束，但不会对另外一个进程造成影响。多线程程序，一个进程结束，有可能会造成其他线程的结束

线程应用

线程的状态图解析：
(1) 新建状态：即新建一个线程对象，设置好需要执行的任务
(2) 就绪状态：调用线程的start方法，进入准备状态,等待cpu分配时间片段
(3) 运行状态： 当cpu将时间片段给了线程对象后，线程开始执行任务。
(4) 阻塞状态：正在运行中的线程由于某种原因，放弃了cpu的使用权，也就是放弃时间片段，进入阻塞状态。
阻塞状态分为三种：
等待阻塞：运行中的线程调用wait方法时，jvm将此线程放入等待池中
同步阻塞：运行中的线程想要获取同步的锁对象时，如果锁对象被其他线程占用，则jvm将此线程放入锁池中
其他阻塞：当线程中执行到阻塞方法或者是Thread.sleep()或者是其他线程的join时，该线程进行阻塞状态
(5) 死亡状态：当线程执行完任务后，表示结束。

线程的创建方式(3种)

(1)继承Thread类，重写run方法，定义任务内容。然后调用start方法，用于启动线程。(切记，不是调用run方法)
(2)实现接口Runnable，重写run方法，定义任务内容，然后将任务传给Thread对象，然后由Thread调用strat方法，执行任务
(3)创建接口Callable的实现类，并实现call方法，call方法有返回值，并使用FutureTask类来包装Callable实现类的对象，再将FutureTask对象传给Thread对象，调用start方法，启动线程
第二种方式与第一种比较：
(1)将线程对象和任务对象分开，降低了耦合度，便于维护
(2)避免了java中单继承的限制
(3)适合相同的任务代码块处理同一个资源

public class ThreadDemo01 {
	public static void main(String[] args) {
		//创建线程对象，启动线程
		Thread t1 = new MyTask();
		Thread t2 = new MyTask();
		
		t1.start();
		t2.start();
		System.out.println("main方法over");
		
	}
}
/**方法1:通过继承Thread，完成线程的定义*/
class MyTask extends Thread{
	//重写run方法
	@Override
	public void run() {
		for(int i=0;i<100000;i++) {
			System.out.println(this.getName()+":1");
		}
	}
}

public class ThreadDemo02 {
	public static void main(String[] args) {
		Runnable r1 = new MyTask1();
		Thread t1 = new Thread(r1);
		
		Runnable r2 = new MyTask1();
		Thread t2 = new Thread(r2);
		
		t1.start();
		t2.start();
		System.out.println("main方法结束");
		
	}
}
/**方法2:实现接口，完成任务的定义*/
class MyTask1 implements Runnable{
	//重写run方法，定义任务体
	@Override
	public void run() {
		//随机一个整数，输出500次，
		int num = (int)(Math.random()*100);
		for(int i=0;i<500;i++) {
			System.out.println(num);
		}
	}
}

public class ThreadDemo03 {
    public static void main(String[] args) {
        Callable<Integer> myCallable = new MyCallable();    // 创建MyCallable对象
        FutureTask<Integer> ft = new FutureTask<Integer>(myCallable); //使用FutureTask来包装MyCallable对象
        Callable<Integer> c = new MyCallable();

        Thread t = new Thread(ft);   //FutureTask对象作为Thread对象的target创建新的线程
        t.start();                      //线程进入到就绪状态
    }
}
class MyCallable implements Callable<Integer> {
    private int i = 0;

    // 与run()方法不同的是，call()方法具有返回值
    @Override
    public Integer call() {
        int sum = 0;
        for (; i < 100; i++) {
            System.out.println(Thread.currentThread().getName() + " " + i);
            sum += i;
        }
        return sum;
    }
}

常用构造器：
Thread(Runnable r) 创建一个指定任务的线程对象
Thread(Runnable r,String name) 创建一个指定任务，并且指定名称的线程对象
Thread(String name) 创建一个指定名称的线程对象

常用方法：
String getName()
long getId()
int getPriority()
State getState()
boolean isAlive()
boolean isDaemon()
boolean isInterrupt();

线程调度：
多线程时，谁先执行是不可控的，是由cpu的线程调度来分配的。但是我们可以通过线程的优先级来尽可能的让线程调度来调控线程所需要的时间片段。优先级:从1-10，越来越高。1是最低的优先级，对应的常量：MIN_PRIORITY，10是最高的优先级：MAX_PRIORITY，5是默认的优先级: NORM_PRIORITY 方法：
void setPriority(int priority)
守护线程：
线程共分两大类：分别为普通线程和守护线程，多线程程序，在只剩下守护线程时，会结束所有线程。方法：
void setDaemon(boolean flag) 设置为true时，是守护线程。

static void sleep(long time) 使当前线程放弃时间片段，进入阻塞状态，超时后，会进入就绪状态。如果没有超时，而是被打断，会出现检查性异常:InterruptException
void interrupt() 打断阻塞状态下的线程对象。
void join() 将当前线程A加入到线程B中，线程B进入阻塞状态，直到线程A结束，线程B进入就绪状态，等待被分配时间片段。

static void yield() 线程对象让步的功能：让出时间片段，此线程进入就绪状态。

同步锁

当多个线程操作临界资源时，可能会出现线程安全隐患问题。
临界资源可能是：
(1)某一个静态变量
(2)某一个实例变量
如果想解决这样的问题，需要使用同步操作。

异步操作：多线程的并发操作，相当于各干各的
同步操作：相当于一个做完，另一个再做。

线程在内部提供了一个内置的锁机制保证原子性，用于线程进行同步操作。
锁需要两点：
  (1) 锁是一个对象，
  (2) 如果想进行同步，多个现象操作的必须是同一个锁
synchronized(锁对象的引用){
   需要同步的代码块
   }
锁机制：当一个线程进入同步的代码块后，就会获得锁对象的使用权。其他线程如果执行到此处，会发现锁对象被占用，只能处于等待状态(锁池)，当线程执行完同步的代码后或者出现异常，都会自动释放锁。

合适的锁对象：必须是一个引用类型，而且必须使多个线程都可以使用这个锁对象，因此this对象比较适合

同步代码块的范围:
(1)可以是方法内的一部分代码，可以也是全部代码(相当于给方法上了锁)
(2)成员方法上添加修饰词synchronized，锁对象为this如果一个类的所有成员方法都使用了同步关键字，当某一个线程操作了其中一个方法，另外的线程即使操作的不是这个方法，也会进入锁池状态
(3)静态方法上也可以添加synchronized，锁对象为类对象，调用方法：类名.class，每一种类都有一个唯一的类对象

wait()/notify()/notifyAll():

上述的方法都是Object类型提供的，用来调控线程的状态的。使用位置必须是同步块中，如果不是同步块中，会报异常

wait() 当前获取锁对象的线程准备释放锁，给其他线程获取锁的机会。
wait(long time) 当前获取锁对象的线程如果没有被通知，在延迟time毫秒后，自动释放锁对象
wait(long time,int naons) 功能一样，只不过比上一个方法延迟的时间更加精确。

notify()/notifyAll() 当前获取锁对象的线程准备释放锁，使用此方法通知处于使用wait方法等待的线程，
   notify() 只会随机通知等待线程中的其中一个。
   notifyAll() 通过所有等待的线程来竞争锁。

生产者--消费者--仓库模式：此模式脱离了仓库没有任何意义。
   (1)仓库用来存储数据。
   (2)仓库不满的情况下，生产者可以生产
   (3)仓库中满足消费者的需求时，消费者就可以消费

线程池

      (1)如果每个任务都需要创建线程对象，内存开销大
      (2)方便管理线程对象。
   线程池的原理：就是一些线程的集合，线程的状态不是死亡状态，当线程池接收外面的任务时，线程池的管理器会查看是否有空闲线程，如果有，就会将任务分配给它，如果没有，任务处于等待队列中.
   线程池的类型：ExecutorService另外一个类Executors里提供了多个静态方法来获取线程池对象

常用方法：
  static ExecutorService newSingleThreadExecutor() 获取单个线程的线程池对象，内部维护了一个无界队列用于存储任务
  static ExecutorService newFixedThreadPool(int nThreads) 创建一个固定数量线程的线程池，维护一个为无界队列
  static ExecutorService newCachedThreadPool() 创建一个可以根据需求来创建新线程的线程池对象，如果有可重用的，会优先使用。
  static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) 创建一个线程池，可以进行设置延迟或者是定时来执行任务

/**
 * 单个线程的线程池：维护一个无界队列
 */
public class ThreadPoolDemo01 {
	public static void main(String[] args) {
		ExecutorService pool = 
				Executors.newSingleThreadExecutor();
		Task r1 = new Task("小A");
		Task r2 = new Task("小B");
		Task r3 = new Task("小C");
		Task r4 = new Task("小D");
		Task r5 = new Task("小E");
		/*
		 * 此线程池：会按照添加任务的顺序执行任务
		 * */
		pool.execute(r1);
		pool.execute(r2);
		pool.execute(r3);
		pool.execute(r4);
		pool.execute(r5);
		System.out.println("main方法结束");
	}
}
class Task implements Runnable{
	private String name;
	public Task(String name) {
		this.name = name;
	}
	public void run() {
//		synchronized (Task.class) {
			for(int i=1;i<11;i++) {
				System.out.println(name+":"+i);
			}
//		}
	}
	
}

public class ThreadPoolDemo04 {
	public static void main(String[] args) throws Exception {
		ScheduledExecutorService pool = 
				Executors.newScheduledThreadPool(2);
		
		Runnable r1 = new Run(100);
		Runnable r2 = new Run(200);
		Runnable r3 = new Run(300);
		Runnable r4 = new Run(400);
		Runnable r5 = new Run(500);
		
		pool.schedule(r1, 5, TimeUnit.SECONDS);
		pool.execute(r2);
		pool.execute(r3);
		pool.execute(r4);
		pool.schedule(r5, 15, TimeUnit.SECONDS);
	   
		pool.shutdown();
	}
}

JAVA基础（26）-Java多线程基础，