JAVA_多线程

1. 进程和线程：

2. 多线程：
如果在一个进程中同时运行了多个线程，用来完成不同的工作，则称之为“多线程”。多个线程交替占用CPU资源，而非真正的并行执行。
3. 多线程的好处：
（1）充分利用CPU的资源
（2）简化编程模型
（3）带来良好的用户体验
4.主线程：
（1）Thread类：Java提供了java.lang.Thread类支持多线程编程。
（2）主线程：
main()方法即为主线程入口
产生其他子线程的线程
必须最后完成执行，因为它执行各种关闭动作
（3）显示主线程名：

public static void main(String args[]) {
    Thread t= Thread.currentThread();
    **System.out.println("当前线程是: "+t.getName());**
    t.setName("MyJavaThread");
    **System.out.println("当前线程名是: "+t.getName()); }**

5.线程的创建和启动：
（1） 在JAVA中创建线程的两种方式：
继承java.lang.Thread类
实现java.lang.Runnable接口
（2） 使用线程的步骤：
定义线程—>创建线程对象—>启动线程——>终止线程
6. 继承Thread类创建线程2-1：
定义MyThread类继承Thread类
重写run()方法，编写线程执行体
创建线程对象，调用start()方法启动线程

public class MyThread extends Thread{
    //重写run()方法
	public void run(){
	for(int i=1;i<100;i++){
System.out.println(Thread.currentThread().getName()+":"+i);
}}}

public static void main(String[] args) {
		MyThread thread = new MyThread();
		thread.start(); //启动线程
}

7. 继承Thread类创建线程2-2：
多个线程交替执行，不是真正的“并行”
线程每次执行时长由分配的CPU时间片长度决定
8. 启动线程是否可以直接调用run()方法？

9. 实现Runnable接口创建线程
定义MyRunnable类实现Runnable接口
实现run()方法，编写线程执行体
创建线程对象，调用start()方法启动线程

10. 比较两种创建线程的方式

11.线程的状态

12.线程调度
线程调度指按照特定机制为多个线程分配CPU的使用权。

13. 线程优先级
线程优先级由1~10表示，1最低，默认优先级为5
优先级高的线程获得CPU资源的概率较大

public static void main(String[] args) {
		Thread t1 = new Thread(new MyThread(),"线程A");
   Thread t2 = new Thread(new MyThread(),"线程B");
		t1.setPriority(Thread.MAX_PRIORITY);
		t2.setPriority(Thread.MIN_PRIORITY);
       //省略代码……
	}}

14. 线程休眠
    让线程暂时睡眠指定时长，线程进入阻塞状态
    睡眠时间过后线程会再进入可运行状态

public static void sleep(long millis); 
 // millis为休眠时长，以毫秒为单位

public class Wait {
    public static void bySec(long s) {
         for (int i = 0; i < s; i++) {
             System.out.println(i + 1 + "秒");
             try {
 //调用sleep()方法需处理InterruptedException异常
	           Thread.sleep(1000); 
             } catch (InterruptedException e) {
         	e.printStackTrace();
}}}}

15. 线程的强制运行
    使当前线程暂停执行，等待其他线程结束后再继续执行本线程。

public static void main(String[] args) {
      Thread temp = new Thread(new MyThread());
      temp.start();
      for(int i=0;i<20;i++){
           if(i==5){				
           try {
	temp.join();
           } catch (InterruptedException e) {
	e.printStackTrace(); }}			
              System.out.println(Thread.currentThread().getName()+"运行："+i);
           } 
              //省略代码…
}

16. 线程的礼让
    暂停当前线程，允许其他具有相同优先级的线程获得运行机会。该线程处于就绪状态，不转为阻塞状态。（**只是提供一种可能，但是不能保证一定会实现礼让）

public class MyThread implements Runnable{
     public void run(){
          for(int i=0;i<5;i++){
   **加粗样式**         	System.out.println(Thread.currentThread().
              getName()+"正在运行："+i);
    	    if(i==3){
    	       System.out.print("线程礼让：");
	           Thread.yield();	//当i=3时，当前线程礼让
} } }}

17. 多线程共享数据引发的问题
    多个线程操作同一共享资源时，将引发数据不安全问题。
    18. 同步方法
    使用synchronized修饰的方法控制对类成员变量的访问
    synchronized就是为当前的线程声明一把锁

形式1：访问修饰符 synchronized 返回类型 方法名（参数列表）{……}
形式2：synchronized 访问修饰符 返回类型 方法名（参数列表）{……}

19. 同步代码块
使用synchronized关键字修饰的代码块

// syncObject为需同步的对象，通常为 this   
//效果与同步方法相同  
synchronized(syncObject){    
    //需要同步的代码      
}

public void run() {
    while (true) {
        synchronized (this) {   //同步代码块
        // 省略修改数据的代码......
       // 省略显示信息的代码......
}}}

当多个并发线程访问同一资源的同步代码块时：
（1）同一时刻只能有一个线程进入synchronized（this）同步代码块
（2）当一个线程访问一个synchronized（this）同步代码块时，其他synchronized（this）同步代码块同样被锁定
（3）当一个线程访问一个synchronized（this）同步代码块时，其他线程可以访问该资源的非synchronized（this）同步代码
20. 线程安全的类型
ArrayList类的add()方法为非同步方法。当多个线程向同一个ArrayList对象添加数据时，可能出现数据不一致问题。（ArrayList为非线程安全的类型）

21. 常见类型对比
Hashtable：
（1）继承关系（实现了Map接口，Hashtable继承Dictionary类）
（2）线程安全，效率较低
（3）键和值都不允许为null
HashMap：
（1）继承关系（实现了Map接口，继承AbstractMap类）
（2）非线程安全，效率较高
（3）键和值都允许为null
StringBuffer 线程安全
StringBuilder 非线程安全