Java多线程学习总结_java多线程总结及体会-CSDN博客

本文链接：https://blog.csdn.net/wei17621648823/article/details/105351833

Java多线程学习总结

Java多线程

Java多线程

本人小白，在学习完java多线程之后收获的一些知识点与总结，希望可以帮助到想了解java多线程的你们，如有错误，请大神们指出，共同学习进步！

线程与进程

在了解多线程之前，我们先来了解一下什么是进程什么是线程：

进程： 指的是一个内存中运行中的应用程序，每个进程中都有自己独立的内存空间且至少包含一个线程；
线程： 指的是进程中的一个执行任务（控制单元），一个进程可以同时并发多个线程（多线程）；

并行与并发

并行： 两个或多个事件（线程）在同一时间段同一时刻同时发生（多个CPU执行）
并发： 两个或多个事件（线程）在同一时间段交替发生（多线程）
--------- 两者的区别在于是否是同时发生

线程的使用

1.线程的创建

(1).继承Thread类

public class MyThread extends Thread{
	@Override
	public void run(){
		//线程操作.....
	}
	public static void Main(String [] args){
		MyThread th = new MyThread("MyThread");
		//启动线程
		th.start();
	}
}

(2).实现Runnable接口

public class MyRunnable implements Runnable{
	@Override
	public void run(){
		//线程操作....
	}
	public static void Main(String [] args){
		//创建runnable对象
		MyRunnable runnable= new MyRunnable ();
		//通过Thread类的构造函数创建线程
		Thread th = new Thread(runnable,"MyThread");
		//启动线程
		th.start();
	}
}

优点：

可以避免由于java单继承带来的局限
增强程序的健壮性，代码能够被多个线程共享，代码和数据是=数据是独立的
适合多个相同程序代码的线程区处理同意资源的情况

2.线程常用的方法

(1).start()方法

----线程开始执行；Java虚拟机调用此线程的run方法。

(2).run()方法

----如果这个线程使用单独的Runnable运行对象构造，则调用该Runnable对象的run方法; 否则，此方法不执行任何操作并返回。

(3).sleep(long millis,int nanos)方法

---- 导致正在执行的线程以指定的毫秒数加上指定的纳秒数来暂停（临时停止执行）。此方法为Thread类的静态方法，通过Thread.sleep()方式调用，有两个重载的方法sleep(long mills),sleep() 。

/**
 * @author Asus
 */
public class SleepTest extends Thread {
    /**
     * 调用Thread类构造函数给线程命名
     * @param name 线程名
     */
    public SleepTest(String name) {
        super(name);
    }
    @Override

    public void run(){
        for (int i = 0; i < 3; i++) {
            System.out.println(getName()+"----正在执行"+i);
            try {
            	//执行到I=1时线程礼让，正在执行的线程进入休眠状态
                if (i==1) {
                    Thread.sleep(1000, 100);
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) {
        SleepTest th1 = new SleepTest("Thread1");
        SleepTest th2 = new SleepTest("Thread2");
        th1.start();
        th2.start();
    }
}

结果：
在这里插入图片描述

(4).join()方法

等待这个线程（执行join()方法的线程例如执行了A.join()则等待A线程死亡）死亡，例如：线程A执行了thread.join()方法，则线程A等待thread线程终止后才从thread方法返回

修改上面main方法代码：

 public static void main(String[] args) {
        SleepTest th1 = new SleepTest("Thread1");
        SleepTest th2 = new SleepTest("Thread2");
        th1.start();
        //线程1执行join()方法
        th1.join();
        th2.start();
    }

结果：
在这里插入图片描述
解析：

Thread1和Thread2都在main方法中执行，故两者都为main线程的子线程，线程创建完毕后执行th1.start(),Thread1获取CPU资源开始执行，执行到th1.join()时main线程挂起等待Thread1执行完毕释放CPU资源，与thread2无关，被挂起的为main主线程

(4).yeild()方法

造成当前正在执行的线程对象临时性的暂停，允许其他线程去执行

(5).currentThread()方法

返回对当前正在执行的线程对象的引用。此方法为Thread类的静态方法，返回当前正在执行的线程对象的引用 Thread.currentThread();

还有很多常用的方法，例如 getName() 返回此线程名称，getPriority() 返回此线程的优先级，getState()返回此线程的状态等等详情请参考jdk API文档

3.多线程的使用实例

使用wait()方法与notify()方法实现交替打印26个字母和数字

wait()方法：

Object类的方法 - - - 导致当前线程等待，直到另一个线程调用该对象的 notify()方法或 notifyAll()方法。

notify()&notifyAll()方法：

唤醒正在等待对象监视器的单个&所有线程。

代码如下：

/**
 * @author Asus
 */
public class Test {
    private static Object lock = new Object();
    public static void main(String[] args) {
        Thread th1 = new Thread(){
            @Override

            public void run(){
                synchronized (lock) {
                    for (int i = 1; i <= 26; i++) {
                        System.out.println(i);
                        lock.notify();

                    try {
                        lock.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                     }
                    }
                }
            };
        };
        th1.start();
        Thread th2 = new Thread(){
          @Override
          
          public void run(){
              synchronized (lock) {
                  for (int i = 1; i <= 26; i++) {
                      System.out.println((char)(i+64));
                      lock.notify();
                      try {
                          lock.wait();
                      } catch (InterruptedException e) {
                          e.printStackTrace();
                      }
                  }
              }
          }  
        };
        th2.start();
    }
}