java多线程入门讲解

最新推荐文章于 2023-01-13 09:22:53 发布

置顶弱即弱离

最新推荐文章于 2023-01-13 09:22:53 发布

阅读量146

点赞数

文章标签： java 多线程

本文链接：https://blog.csdn.net/qq_41577650/article/details/105311749

版权

一、Java线程的五个基本状态：新建，就绪，运行，阻塞，死亡。

在这里插入图片描述
(1)新建（New）：当线程对象对创建后，即进入了新建状态；
(2)就绪（Runnable）：当调用线程对象的start()方法，线程即进入就绪状态。处于就绪状态的线程，只是说明此线程已经做好了准备，随时等待CPU调度执行，并不是说执行了start()此线程立即就会执行；
(3)运行（Running）：当CPU开始调度处于就绪状态的线程时，此时线程才得以真正执行，即进入到运行状态。注：就绪状态是进入到运行状态的唯一入口，也就是说，线程要想进入运行状态执行，首先必须处于就绪状态中；
(4)阻塞（Blocked）：处于运行状态中的线程由于某种原因，暂时放弃对CPU的使用权，停止执行，此时进入阻塞状态，直到其进入到就绪状态，才有机会再次被CPU调用以进入到运行状态。根据阻塞产生的原因不同，阻塞状态又可以分为三种：
1>等待阻塞:运行状态中的线程执行wait()方法，使本线程进入到等待阻塞状态；
2>同步阻塞:线程在获取synchronized同步锁失败(因为锁被其它线程所占用)，它会进入同步阻塞状态；
3>其他阻塞:通过调用线程的sleep()或join()或发出了I/O请求时，线程会进入到阻塞状态。当sleep()状态超时、join()等待线程终止或者超时、或者I/O处理完毕时，线程重新转入就绪状态。
(5)死亡（Dead）：线程执行完了或者因异常退出了run()方法，该线程结束生命周期

二. Java多线程的创建及启动

1.继承Thread类，重写该类的run()方法。

 public class MyThread extends Thread{
	private int i = 0;
	@Override
	public void run() {
		for (i = 0; i < 100; i++) {
			System.out.println(Thread.currentThread().getName() + " " + i);
		}
	}

public static void main(String[] args) {
		    Thread myThread1 = new MyThread(); //创建线程1  	
			Thread myThread2 = new MyThread(); // 创建线程2			myThread1.start(); // 调用start()方法使得线程进入就绪状态
			myThread2.start(); // 调用start()方法使得线程进入就绪状态
	}

}

完事我们来看看Thread类里的run（）方法
在这里插入图片描述

target本身就是一个Runnable对象，执行的是该对象的run（）方法，而Thread本身就是实现Runnable接口的，所以我们可以采用第二种方式创建一个线程
2. 实现Runnable接口，并重写该接口的run()方法，

 public class MyRunnable implements Runnable {
	private int i = 0;

	@Override
	public void run() {
		System.out.println("in MyRunnable run");
		for (i = 0; i < 100; i++) {
			System.out.println(Thread.currentThread().getName() + " " + i);
		}
	}
	
	public static void main(String[] args) {
		Runnable myRunnable = new MyRunnable();
		Thread thread = new Thread(myRunnable);
		thread.start();
	}
}

在这里插入图片描述

这里采用Tread类里这个初始化方法创建线程。
3. 使用Callable和Future接口创建线程。具体是创建Callable接口的实现类，并实现clall()方法。并使用FutureTask类来包装Callable实现类的对象，且以此FutureTask对象作为Thread对象的target来创建线程。

public class MyCallable implements Callable<Integer> {
	private int i = 0;

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

		Callable<Integer> myCallable = new MyCallable();    // 创建MyCallable对象
		FutureTask<Integer> ft = new FutureTask<Integer>(myCallable); //使用FutureTask来包装MyCallable对象
		   Thread thread = new Thread(ft);   //FutureTask对象作为Thread对象的target创建新的线程
		   thread.start();                      //线程进入到就绪状态
		try {
			int sum = ft.get();            //取得新创建的新线程中的call()方法返回的结果
			System.out.println("sum = " + sum);
		} catch (InterruptedException e) {
			e.printStackTrace();
		} catch (ExecutionException e) {
			e.printStackTrace();
		}

	}

}

三：如何中止一个线程：

1.结束一个线程有一个最基本的方法:Thread.stop()方法: 但是这个方法已经是:@Deprecated的了,也就是被建议不要使用的方法. 原因是stop()方法太过于暴力，会强行把执行一半的线程终止。这样会就不会保证线程的资源正确释放，通常是没有给与线程完成资源释放工作的机会，因此会导致程序工作在不确定的状态下。
在这里插入图片描述
2.使用boolean类型的变量，来终止线程，也就是告诉线程什么时候退出。

四：java多线程 interrupt(), interrupted(), isInterrupted()方法区别

**Interrupt（）：**中断线程，且"中断标记"设置为true
interrupted()：判断的是当前线程是否处于中断状态。是类的静态方法，同时会清除线程的中断状态。
isInterrupted():判断调用线程是否处于中断状态

说明：isInterrupted()是判断线程的中断标记是不是为true。当线程处于运行状态，并且我们需要终止它时；可以调用线程的interrupt()方法，使用线程的中断标记为true，即isInterrupted()会返回true。此时，就会退出while循环。
注意：interrupt()并不会终止处于“运行状态”的线程！它是将线程的中断标记设为true。

有时间会给大家详解这一块儿的内容

InterruptedException异常

java多线程 interrupt(), interrupted(), isInterrupted()方法区别
interrupt（）：用于中断线程的，调用该方法的线程的状态将被置为"中断"状态。
仅仅是在当前线程中打了一个停止的标记，并不是真的停止线程，需要用户自己去监视线程的状态为并做处理，一旦遇到阻塞，那么，线程将接收到一个中断异常（InterruptedException），从而提早地终结被阻塞状态。
在这里插入图片描述
上述开启两个线程，i=30时，设置一个中断标记，线程阻塞，抛出InterruptedException异常

isInterrupted()：测试线程（调用该方法的线程）是否已经中断，不清除中断状态。
在这里插入图片描述
**interrupted()：**测试当前线程（当前线程是指运行interrupted()方法的线程）是否已测试当前线程是否已经中断，清除中断状态。

在这里插入图片描述

线程的中断状态由interrupted方法清除。换句话说，如果连续两次调用该方法，则第二次调用将放回false（在第一次调用已经清除了其中断的状态之后，且第二次调用检验完中断状态之前，当前线程再次中断的情况除外）。经中断，且清除中断状态。通过分析源码我们不难发下interrupted（）最终调用的还是isInterrupted（）；只不过一个作用于当前线程，一个作用于调用该方法的线程，一个清除中断标记，一个不清除中断标记。

Java 守护线程

Java的线程分为两种：User Thread(用户线程)、DaemonThread(守护线程)。

只要当前JVM实例中尚存任何一个非守护线程没有结束，守护线程就全部工作；只有当最后一个非守护线程结束是，守护线程随着JVM一同结束工作，Daemon作用是为其他线程提供便利服务，守护线程最典型的应用就是GC(垃圾回收器)，他就是一个很称职的守护者。
User和Daemon两者几乎没有区别，唯一的不同之处就在于虚拟机的离开：如果 User Thread已经全部退出运行了，只剩下Daemon
Thread存在了，虚拟机也就退出了。因为没有了被守护者，Daemon也就没有工作可做了，也就没有继续运行程序的必要了。

首先看一个例子，主线程中建立一个守护线程，当主线程结束时，守护线程也跟着结束。
在这里插入图片描述

子线程设置为守护线程，主线程结束，子线程也结束。

在这里插入图片描述
主线程结束，子线程仍然运行。

可以看到，当主线程结束时，childThread是非守护线程，就会无限的执行。

守护线程有一个应用场景，就是当主线程结束时，结束其余的子线程（守护线程）自动关闭，就免去了还要继续关闭子线程的麻烦。不过博主推荐，如果真有这种场景，还是用中断的方式实现比较合理。
还有补充一点，不是说当子线程是守护线程，主线程结束，子线程就跟着结束，这里的前提条件是：当前jvm应用实例中没有用户线程继续执行，如果有其他用户线程继续执行，那么后台线程不会中断

在这里插入图片描述

回归正题，这里有几点需要注意：
(1) thread.setDaemon(true)必须在thread.start()之前设置，否则会跑出一个IllegalThreadStateException异常。你不能把正在运行的常规线程设置为守护线程。
(2) 在Daemon线程中产生的新线程也是Daemon的。
(3) 不要认为所有的应用都可以分配给Daemon来进行服务，比如读写操作或者计算逻辑。
写java多线程程序时，一般比较喜欢用java自带的多线程框架，比如ExecutorService，但是java的线程池会将守护线程转换为用户线程，所以如果要使用后台线程就不能用java的线程池。
http://www.importnew.com/26834.html

sleep(),wait(),yield(),join()用法和区别。
1.sleep()方法

在指定时间内让当前正在执行的线程暂停执行，但不会释放“锁标志”。不推荐使用。 sleep()使当前线程进入阻塞状态，在指定时间内不会执行。

2.wait()方法

在其他线程调用对象的notify或notifyAll方法前，导致当前线程等待。线程会释放掉它所占有的“锁标志”，从而使别的线程有机会抢占该锁。
当前线程必须拥有当前对象锁。如果当前线程不是此锁的拥有者，会抛出IllegalMonitorStateException异常。
唤醒当前对象锁的等待线程使用notify或notifyAll方法，也必须拥有相同的对象锁，否则也会抛出IllegalMonitorStateException异常。
waite()和notify()必须在synchronized函数或synchronized　block中进行调用。如果在non-synchronized函数或non-synchronized　block中进行调用，虽然能编译通过，但在运行时会发生IllegalMonitorStateException的异常。
说明：wait()释放掉其所占有的“锁标志”，从而使别的线程有机会抢占该锁。但并不意味着彻底放弃该锁，而是重新参与锁竞争，这点必须强调下。

3.yield方法

暂停当前正在执行的线程对象。
yield()只是使当前线程重新回到可执行状态，所以执行yield()的线程有可能在进入到可执行状态后马上又被执行。
说明：yield()只能使同优先级或更高优先级的线程有执行的机会。

4.join方法

等待该线程终止。
等待调用join方法的线程结束，再继续执行。
说明：join线程同样可以阻塞线程，可以保证线程执行的先后顺序，如某程调用join()，只有当该线程执行结束，才会继续执行。
synchronized修饰符
synchronized：可以在任意对象及方法上加锁，当一个线程访问该类的某个数据时，进行保护，其他线程不能进行访问直到该线程读取完，其他线程才可使用。

首先看一下不加锁：

public class SynchronizedThread extends Thread{

	@Override
	public  void  run() {
		while(true) {
		 System.out.println(Thread.currentThread().getName());
		 try {
			this.sleep(1000);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		 }
	}	public static void main(String[] args) {
		SynchronizedThread myThread = new SynchronizedThread();
        Thread thread1 = new Thread(myThread, "thread1");
        Thread thread2 = new Thread(myThread, "thread2");
        Thread thread3 = new Thread(myThread, "thread3");
        Thread thread4 = new Thread(myThread, "thread4");
        Thread thread5 = new Thread(myThread, "thread5");
        thread1.start();
        thread2.start();
        thread3.start();
        thread4.start();
        thread5.start();
	}
}

在这里插入图片描述

多线程并发运行
加锁

public class SynchronizedThread extends Thread{

	@Override
	public synchronized void  run() {
		while(true) {
		 System.out.println(Thread.currentThread().getName());
		 try {
			this.sleep(1000);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		 }
	}
	public static void main(String[] args) {
		SynchronizedThread myThread = new SynchronizedThread();
        Thread thread1 = new Thread(myThread, "thread1");
        Thread thread2 = new Thread(myThread, "thread2");
        Thread thread3 = new Thread(myThread, "thread3");
        Thread thread4 = new Thread(myThread, "thread4");
        Thread thread5 = new Thread(myThread, "thread5");
        thread1.start();
        thread2.start();
        thread3.start();
        thread4.start();
        thread5.start();
	}
}

在这里插入图片描述

说明：当多个线程访问SynchronizedThread的run方法的时候，如果使用了synchronized修饰，那个多线程就会以排队的方式进行处理（这里排队是按照CPU分配的先后顺序而定的），一个线程想要执行synchronized修饰的方法里的代码，首先是尝试获得锁，如果拿到锁，执行synchronized代码体的内容，如果拿不到锁的话，这个线程就会不断的尝试获得这把锁，直到拿到为止。

//多线程-单例设计模式-懒汉式出现的安全问题

public class SingleDemo {  
    private static SingleDemo Single = null;  
    private SingleDemo(){}  
    public static  SingleDemo getInstance(){  
        if(Single == null){  
        	Single = new SingleDemo();  
        }  
        return Single;  
    } 
    
    public static void main(String[] args) {  
        SingleDemo s1 = SingleDemo.getInstance();  
        SingleDemo s2 = SingleDemo.getInstance();  
        System.out.println(s2 == s2);  
    }  
}

在这里插入图片描述
貌似没问题
再看下多线程下的访问

public class SynchronizedThread extends Thread{
	
	SingleDemo s =null;
	@Override
	public  void  run() {
		 System.out.println(Thread.currentThread().getName());
		 s = SingleDemo.getInstance();  
		 System.out.println(s);
	}
	public static void main(String[] args) {
		SynchronizedThread myThread = new SynchronizedThread();
        Thread thread1 = new Thread(myThread, "thread1");
        Thread thread2 = new Thread(myThread, "thread2");
        Thread thread3 = new Thread(myThread, "thread3");
        Thread thread4 = new Thread(myThread, "thread4");
        Thread thread5 = new Thread(myThread, "thread5");
        thread1.start();
        thread2.start();
        thread3.start();
        thread4.start();
        thread5.start();
	}
}

在这里插入图片描述
发下其中一个地址出现不同，说明访问了不同的实例。线程不安全。
改进下代码

public class SingleDemo {  
    private static SingleDemo Single = null;  
    private SingleDemo(){}  
    public static  SingleDemo getInstance(){  
        if(Single == null){  
        	Single = new SingleDemo();  
        }  
        return Single;  
    } 
    
    public static synchronized void main(String[] args) {  
        SingleDemo s1 = SingleDemo.getInstance();  
        SingleDemo s2 = SingleDemo.getInstance();  
        System.out.println(s2 == s2);  
    }  
}  

public class SynchronizedThread extends Thread{
	
	SingleDemo s =null;
	@Override
	public  void  run() {
		while(true) {
		 System.out.println(Thread.currentThread().getName());
		 s = SingleDemo.getInstance();  
		 System.out.println(s);
		}
	}
	public static void main(String[] args) {
		SynchronizedThread myThread = new SynchronizedThread();
        Thread thread1 = new Thread(myThread, "thread1");
        Thread thread2 = new Thread(myThread, "thread2");
        Thread thread3 = new Thread(myThread, "thread3");
        Thread thread4 = new Thread(myThread, "thread4");
        Thread thread5 = new Thread(myThread, "thread5");
        thread1.start();
        thread2.start();
        thread3.start();
        thread4.start();
        thread5.start();
	}
}

在这里插入图片描述
多线程访问同一个实例，线程安全。

public class SynchronizedThread extends Thread {

	private final Object left = new Object();
	private final Object right = new Object();

	public void leftRight() throws Exception {
		synchronized (left) {
			Thread.sleep(2000);
			synchronized (right) {
				System.out.println("leftRight end!");
			}
		}
	}

	public void rightLeft() throws Exception {
		synchronized (right) {
			Thread.sleep(2000);
			synchronized (left) {
				System.out.println("rightLeft end!");
			}
		}
	}
	
	class Thread1 extends Thread
	{
	    private SynchronizedThread sy;
	    
	    public Thread1(SynchronizedThread sy)
	    {
	        this.sy = sy;
	    }
	    
	    public void run()
	    {
	        try
	        {
	            sy.rightLeft();
	        } 
	        catch (Exception e)
	        {
	            e.printStackTrace();
	        }
	    }
	}
	
	class Thread0 extends Thread
	{
	    private SynchronizedThread sy;
	    
	    public Thread0(SynchronizedThread sy)
	    {
	        this.sy = sy;
	    }
	    
	    public void run()
	    {
	        try
	        {
	        	sy.leftRight();
	        } 
	        catch (Exception e)
	        {
	            e.printStackTrace();
	        }
	    }
	}
	
	public static void main(String[] args) {
		SynchronizedThread sy = new SynchronizedThread();
		Thread0 t0 = new Thread0(sy);
	    Thread1 t1 = new Thread1(sy);
	    t0.start();
	    t1.start();

	    while(true);   

	}

弱即弱离

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
java多线程入门讲解

一、Java线程的五个基本状态：新建，就绪，运行，阻塞，死亡。(1)新建（New）：当线程对象对创建后，即进入了新建状态；(2)就绪（Runnable）：当调用线程对象的start()方法，线程即进入就绪状态。处于就绪状态的线程，只是说明此线程已经做好了准备，随时等待CPU调度执行，并不是说执行了start()此线程立即就会执行；(3)运行（Running）：当CPU开始调度处于就绪状态的...
复制链接

扫一扫