JAVA多线程基础（一）

最新推荐文章于 2024-03-10 23:38:03 发布

vnicer

最新推荐文章于 2024-03-10 23:38:03 发布

阅读量757

点赞数

分类专栏： JavaSE

本文链接：https://blog.csdn.net/vnices/article/details/8794886

版权

JavaSE 专栏收录该内容

7 篇文章 0 订阅

订阅专栏

理论知识：

点击运行一个程序，则表示一个进程（一个进行中的程序），该程序被加载到内存后，该程序有一系列线程,进程是不会直接执行的,它只
会去分配程序的内存空间，而是线程来负责执行，一个进程中是不可能没有线程的,所以线程就是进程中负责程序执行的一个控制单元。
一个进程中的多个线程执行路径叫做多线程。
在Windows中，你可以开启多个程序。比如打开QQ聊天的同时去开启酷狗听歌，再开启PPTV去看电影。这些程序表面上看起来是在同
时运行，实际上CPU只会在同一时间执行同一个程序，但是会快速的切换处理,而且处理时间也是不规律的。
多线程的好处：解决了多部分同时运行的问题。
多线程的弊端：线程太多回收效率也很低
JVM启动时就启动了多个线程，至少有连个线程：1执行main函数的线程，2负责垃圾回收的线程
Java中的多线程
API文档中对多线程的介绍
每个线程都有一个优先级，高优先级线程的执行优先于低优先级线程。每个线程都可以或不可以标记为一个守护程序。当某个线程中运行的代码创建一个新 Thread 对象时，该新线程的初始优先级被设定为创建线程的优先级，并且当且仅当创建线程是守护线程时，新线程才是守护程序。
当 Java 虚拟机启动时，通常都会有单个非守护线程（它通常会调用某个指定类的 main 方法）。Java 虚拟机会继续执行线程，直到下列
任一情况出现时为止：
调用了 Runtime 类的 exit 方法，并且安全管理器允许退出操作发生。
非守护线程的所有线程都已停止运行，无论是通过从对 run 方法的调用中返回，还是通过抛出一个传播到 run 方法之外的异常。创建新执行线程有两种方法。一种方法是将类声明为 Thread 的子类。该子类应重写 Thread 类的 run 方法。接下来可以分配并启动该子类的实例
Thread类用于描述线程，线程是需要任务的，Thread类也是对任务的描述，这个任务就是通过Thread类中的run方法来实现，也就是说run()方法就是封装自定义线程运行任务的函数，run方法中就是线程要运行的任务代码。
另一种方法是声明实现 Runnable 接口的类。该类然后实现 run 方法。然后可以分配该类的实例，在创建 Thread 时作为一个参数来传
递并启动
创建线程的目的：是为了开启一条执行路径，去运行指定的代码和其他代码实现同时运行，而运行的指定代码就是这个执行路径的任务。

===============================================================================\

/*
	创建线程的方式一：继承Thread类


	步骤：
	1。定义一个类继承Thread类
	2。覆盖Thread类中的run方法。
	3。直接创建Thread类的子类对象创建线程
	4。调用start方法开启线程，并调用线程的运行
	//Thread.currentThread().getName() 得到当前线程的名称
*/


class Demo extends Thread
{
	private String name;
	public Demo(String name){
		this.name=name;
	}
	public void run(){
		for(int i=0;i<10;i++){
			System.out.println(name+"i:"+i+".currentThreadName===>"+Thread.currentThread


().getName());
		}
	}
}


class ThreadDemo
{
	public static void main(String []args){
		Demo d1=new Demo("===>线程A");
		Demo d2=new Demo("==========>线程B");
		d1.start();//这里必须开启线程。他会去调用run方法。执行线程中的内容。而不是直接执行run方法
		d2.start();
	}
}

================================================================
===>线程Ai:0.currentThreadName===>Thread-0
===>线程Ai:1.currentThreadName===>Thread-0
==========>线程Bi:0.currentThreadName===>Thread-1
===>线程Ai:2.currentThreadName===>Thread-0
==========>线程Bi:1.currentThreadName===>Thread-1
===>线程Ai:3.currentThreadName===>Thread-0
==========>线程Bi:2.currentThreadName===>Thread-1
===>线程Ai:4.currentThreadName===>Thread-0
==========>线程Bi:3.currentThreadName===>Thread-1
==========>线程Bi:4.currentThreadName===>Thread-1
===>线程Ai:5.currentThreadName===>Thread-0
==========>线程Bi:5.currentThreadName===>Thread-1
===>线程Ai:6.currentThreadName===>Thread-0
==========>线程Bi:6.currentThreadName===>Thread-1
===>线程Ai:7.currentThreadName===>Thread-0
===>线程Ai:8.currentThreadName===>Thread-0
==========>线程Bi:7.currentThreadName===>Thread-1
===>线程Ai:9.currentThreadName===>Thread-0
==========>线程Bi:8.currentThreadName===>Thread-1
==========>线程Bi:9.currentThreadName===>Thread-1
===============================================================================
如果直接调用run方法则没有实现多线程
调用run方法和调用start方法的区别：
区别：调用start方法实现多线程，而调用run方法没有实现多线程
Start:
用start方法来启动线程，真正实现了多线程运行，这时无需等待run方法体代码执行完毕而直接继续执行下面的代码。通过调用Thread类的start()方法来启动一个线程，这时此线程处于就绪（可运行）状态，并没有运行，一旦得到spu时间片，就开始执行run()方法，这里方法run()称为线程体，它包含了要执行的这个线程的内容，Run方法运行结束，此线程随即终止。
Run:
run()方法只是类的一个普通方法而已，如果直接调用Run方法，程序中依然只有主线程这一个线程，其程序执行路径还是只有一条，还是要顺序执行，还是要等待run方法体执行完毕后才可继续执行下面的代码，这样就没有达到写线程的目的。

总结：调用start方法方可启动线程，而run方法只是thread的一个普通方法调用，还是在主线程里执行。

每个线程在栈内存中都有独立的空间。当线程运行完成或抛出了异常，则结束该线程。

第二种方法创建线程：实现Runnable接口

/*
	创建线程的方式二：实现Runnable接口
	1,定义一个类实现Runnable。
	2,覆盖接口中的run()方法，将线程的代码封装到run方法中().
	3,通过Thread类创建线程对象，然后将实现了Runnable的子类对象作为构造函数的参数进行传递
	（因为线程的任务都封装在实现了Runnable接口的子类对象的run方法中，所以要在线程对象创建时就要明确要运行的任务）
	4,调用线程的start方法开启线程。
*/

class Demo implements Runnable
{
	
	public void run(){
		show();
	}
	public void show(){
		for(int i=0;i<10;i++){
			System.out.println(Thread.currentThread().getName()+"----i="+i);
		}
	}
}

class ThreadDemo
{
	public static void main(String []args){
		Demo d=new Demo();

		Thread t1=new Thread(d);
		Thread t2=new Thread(d);
		t1.start();
		t2.start();
	}
}

实现Runnable接口的好处：
1 将线程的任务从线程的子类中分离出来，进行单独的封装，按照面向对象的思想将任务封装成对象
2 避免了Java单继承的局限性

多线程的状态：
临时阻塞状态，比如说现在有甲乙丙丁四个线程，其中丙和丁通过sleep方法或wait方法让其变成冻结状态，正在执行的线程为甲和乙
甲和乙这时都有CPU的执行资格，但是cpu在同一时刻只能执行一个线程。如果现在正在执行甲线程，那么甲线程则具有CPU的执行劝，这时乙线程处于临时阻塞状态。

============================================================================================================================

一，线程安全问题产生的原因：
1,多个线程操作共享数据
2,操作共享数据的线程代码有多条
当一个线程在操作共享数据的多条代码过程中，其他线程参与了运算。就会导致线程安全问题的存在。
怎样解决：
就是将多条操作共享数据的线程代码封装起来，当有线程在执行当前这些代码的时候，其他他们是不可以参与运算的。
必须要当前线程把这些代码执行完毕后，其他线程才可以参与运算。在Java中，用同步代码块就可以解决这个问题
synchronized（对象）{//该对象必须是公有的
需要同步的代码块；
}
同步的好处：解决了线程的安全问题。
同步的弊端：相对降低了效率，因为同步外的线程都会判断同步锁。
同步的前提：同步中必须有多个线程并使用的是同一个锁

同步函数:在函数的返回值前面加上synchronized关键字，同步函数所使用的锁是当前调用该函数的对象也就是this.
同步函数和同步代码块的区别:同步函数的锁使用的是固定的this;同步代码块的锁是任意的对象。建议使用同步代码块。
静态函数的同步锁：该函数所属字节码文件对象,可以用getClass方法获取。也可以使用类名.class

二，延迟加载单例模式中涉及到的多线程问题：
class Single{
private static Single s=null;
private Single(){}
public static Single getInstance(){
if(s==null){
synchronized(Single.class){//注意这里的锁不能够使用this.getClass();应为getClass()方法是非静态的，
// 在静态方法中不能调用非静态方法
if(s==null)
s=new Single();
}
}
return s;
}
}

代码如果这样写,这个会先判断s是否等于null,如果为空则进去new 一个Single对象。这样的代码在多线程中是有安全隐患的，因为变量s是共享数据，而且有两句代码都操作了s这个变量。
if(s==null)
{
//如果一个线程运行到这里刚好被切换，另一个线程也进来，同时也满足if判断，如果两个线程都执行完后都会返回一个Single对象，这时也不会保证对象的唯一了。
s=new Single();
}
return s;
这时需要同步
synchronized(Single.class)//因为getInstance()是静态方法，所以需要用到Single的字节码文件锁
{
if(s==null)
s = new Single();
}
其实想上面这样写，代码已经没有问题了。但是如果每次调用这个方法的话都会去同步和判断锁，是很浪费资源的。所以在外面再判断一次。如果s不为空了后，直接返回，就不会进入到同步代码块中，所以第一个判断完全是为了代码执行效率。
if(s==null)
{
synchronized(Single.class)
{
if(s==null)
s = new Single();
}
}
在延时加载单例模式中需要使用双重判断来解决安全问题和效率问题。

三，多线程死锁的问题：
常见的情景之一：同步的嵌套
示例：class Test implements Runnable
{
public boolean flag=false;
private int num=100;
public void run(){
if(flag){
while(true)
synchronized(MyLock.locka){
synchronized(MyLock.lockb){
System.out.println(Thread.currentThread().getName()+"if........"+num--);
}
}
}else{
while(true)
synchronized(MyLock.lockb){
synchronized(MyLock.locka){
System.out.println(Thread.currentThread().getName()+"else........"+num--);
}
}
}
}
}
class MyLock
{
public static final MyLock locka=new MyLock();
public static final MyLock lockb=new MyLock();
}
public class DeadLockTest
{
public static void main(String []args){
Test test=new Test();
Thread t=new Thread(test);
Thread t2=new Thread(test);
t.start();
try{t.sleep(10);}catch(Exception e){}
test.flag=true;
t2.start();
}
}

vnicer

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
JAVA多线程基础（一）

理论知识：点击运行一个程序，则表示一个进程（一个进行中的程序），该程序被加载到内存后，该程序有一系列线程,进程是不会直接执行的,它只会去分配程序的内存空间，而是线程来负责执行，一个进程中是不可能没有线程的,所以线程就是进程中负责程序执行的一个控制单元。一个进程中的多个线程执行路径叫做多线程。在Windows中，你可以开启多个程序。比如打开QQ聊天的同时去开启酷狗听歌，再开启P
复制链接

扫一扫