集合框架之初识多线程

最新推荐文章于 2021-12-24 18:02:34 发布

m0_45442261

最新推荐文章于 2021-12-24 18:02:34 发布

阅读量139

点赞数 1

文章标签：多线程

本文链接：https://blog.csdn.net/m0_45442261/article/details/108901513

版权

在这里插入图片描述

1、进程：在操作系统中，进程是指程序的一次完整运行。过程中内存、处理器以及IO等资源都要为其服务。当出现多个进程时，操作系统采用时间片轮转法（即同一时间段内，会有多个进程抢占资源，但在同一时间点上，只允许一个进程运行。）为进程分配相应的资源。
线程：线程是进程基础上更小的划分，即在一个进程上可以创建多个线程。
1-1、线程、进程的区别与联系
（1）线程是比进程更快的处理单元，而且所占用的资源也小（所以多行程应用也是性能最高的应用）
（2）线程与进程是相互相成的，即线程的存在离不开进程。进程消失，线程一定消失，但线程消失，进程不一定消失。

1-2什么是多线程
如果在一个进程中同时运行了多个线程，用来完成不同的工作，则称之为“多线程”
多个线程交替占用CPU资源，而非真正的并行执行【线程每次执行时长由分配的CPU时间片长度决定
】
1-3多线程好处：充分利用CPU的资源；；简化编程模型：带来良好的用户体验

2.在Java中创建线程的三种方式[]
2-1继承java.lang.Thread类
定义MyThread类继承Thread类
重写run()方法，编写线程执行体
创建线程对象，调用start()方法启动线程
【启动线程不可以直接调用run()方法；调用run(),只有主线程一条执行路径;调用start(),多条执行路径，主线程和子线程并行交替执行】
2-2实现java.lang.Runnable接口。创建Thread类对象，使用Runnable接口实现类的对象作为构造方法的参数【此时优势在于避免了单边性，可以更充分的利用CPU资源】
2-3实现callable接口【此时泛型的使用，提高了代码质量】
3线程的状态有5个【创建，就绪，（阻塞），运行，死亡】
4线程同步原因多个线程操作同一共享资源时，将引发数据不安全问题
解决方式：
4-1多个并发线程访问同一资源的【同步代码块】时
同一时刻只能有一个线程进入synchronized（this）同步代码块
当一个线程访问一个synchronized（this）同步代码块时，其他synchronized（this）同步代码块同样被锁定
当一个线程访问一个synchronized（this）同步代码块时，其他线程可以访问该资源的非synchronized（this）同步代码

4-2使用synchronized【修饰的方法控】制对类成员变量的访问synchronized就是为当前的线程声明一个锁【方法名和返回值类型必须连在一起，访问修饰符和synchronized顺序不影响】
5举例说明哪些是线程安全的类型，哪些是非线程安全的类型？hashtable，【Stringbuffer】;verctor安全，arraylist，hashmap,【StringBuilder】不安全

/**线程笔记1010
*1.程序默认执行主线程，主线程最后执行并关闭资源；先执行当前线程；
2.继承线程，单继承，所以有缺陷不便于共享资源，不如实现runable接口；
3实现runable,run方法重写，叫线程执行体，该线程要完成代码都写在run方法中；
主线程中调用子线程，start （）进行启动；
4.start()启动，不一定执行，只是处于就绪状态，看是否获得抢占资源，否则阻塞或继续运行。CPU交替执行多个线程
5.启动线程不能直接执行run()否则全执行的是主线程方法【此时只执行一条线程路径】，不会执行子线程【要执行子线程必须调用Start（）】；
6.线程数从0开始，如果用到for循环计数，中间记得加分隔符否则Thread-0/1/2会和数字连在一起；

1. //先实现接口类对象，并建立线程对象，start()方法只有线程对象才能调用从而执行子线程，如果用线程对象调用run(),只会执行主线程
8.优先级，叫调度策略【在多个线程中分配cpu使用权的优先级】setPriority(参数1-10);【默认优先级为5】线程先调度优先级低也可能先执行完毕；如果数据多，线程调度优先级低的大概率后执行完毕；
9.【静态方法】线程休眠 sleep（毫秒）；线程礼让【必须是相同优先级下的其他线程，此时线程为就绪状态，不是阻塞状态；只是有礼让的概率，不一定能礼让】，优先执行此线程（当前执行线程暂停）yeild();
【普通方法】子线程优先(等待当前线程终止)jion();中断线程interrup（），是否处于活动状态Boolean isAlive();
10.线程休眠时，可能线程中断异常
11.多线程处理共享数据可能引发数据安全问题【票数越剩越多；两人抢同一张票；】
解决方案1：自定义方法加上sychonized修饰，并用flag进行判断；然后在run()调用自定义的方法

在run()中添加同步代码块

12.线程是一个完整的程序，并且占有独立的内存空间和系统资源；线程时完成一个独立控制流程，是CPU调度和分配资源的最小单元；
/
···java
public class MyThread extends Thread{
public static void main(String[] args) {
//获得线程
Thread thread=MyThread.currentThread();
//获得当前线程名字
System.out.println(“当前线程名字”+thread.getName());
//给线程赋值
thread.setName(“22”);
//获得当前线程名字
System.out.println(“当前线程名字”+thread.getName());
}
}
/*

当前线程名字main
当前线程名字22

*/
**********************************************************************************************************1
package cn.kgc.tyl.test1010;

public class MyThread1 extends Thread {
public void run() {//线程执行体
for (int i = 1; i <=30; i++) {
System.out.println(MyThread1.currentThread().getName()+"–"+i);
}
}
}
*******************************************************************************************2-1
package cn.kgc.tyl.test1010;

public class TestTMyThread1 {
public static void main(String[] args) {
//建立线程对象；
MyThread1 thread1=new MyThread1();
MyThread1 thread2=new MyThread1();
MyThread1 thread3=new MyThread1();
//启动线程
thread1.start();
thread2.start();
thread3.start();

}
}
/**
*
Thread-0–1
Thread-2–1
Thread-1–1
Thread-2–2
Thread-0–2
Thread-2–3
Thread-1–2
Thread-1–3
Thread-1–4
Thread-1–5
Thread-1–6
Thread-1–7
Thread-1–8
Thread-1–9
Thread-1–10
Thread-1–11
Thread-1–12
Thread-1–13
Thread-2–4
Thread-0–3
Thread-2–5
Thread-1–14
Thread-2–6
Thread-0–4
Thread-2–7
Thread-2–8
Thread-2–9
Thread-2–10
Thread-2–11
Thread-2–12
Thread-1–15
Thread-1–16
Thread-1–17
Thread-1–18
Thread-1–19
Thread-1–20
Thread-2–13
Thread-0–5
Thread-0–6
Thread-0–7
Thread-0–8
Thread-0–9
Thread-0–10
Thread-2–14
Thread-1–21
Thread-2–15
Thread-2–16
Thread-2–17
Thread-2–18
Thread-2–19
Thread-2–20
Thread-2–21
Thread-2–22
Thread-2–23
Thread-2–24
Thread-2–25
Thread-2–26
Thread-2–27
Thread-2–28
Thread-2–29
Thread-0–11
Thread-0–12
Thread-0–13
Thread-2–30
Thread-1–22
Thread-1–23
Thread-1–24
Thread-0–14
Thread-0–15
Thread-0–16
Thread-0–17
Thread-0–18
Thread-0–19
Thread-0–20
Thread-0–21
Thread-0–22
Thread-1–25
Thread-0–23
Thread-0–24
Thread-0–25
Thread-1–26
Thread-0–26
Thread-0–27
Thread-1–27
Thread-0–28
Thread-1–28
Thread-0–29
Thread-1–29
Thread-0–30
Thread-1–30

*/
***********************************************************************************************2-2
package cn.kgc.tyl.test1010;

public class MyRunnable implements Runnable {

@Override
public void run() {
	for (int i = 1; i <=30; i++) {
		System.out.println(MyThread1.currentThread().getName()+"--"+i);
	}
}

}
************************************************************************************************3-1
package cn.kgc.tyl.test1010;

public class TestRunnable {
public static void main(String[] args) {
//先实现接口类对象，并建立线程对象，start()方法只有线程对象才能调用从而执行子线程，如果用线程对象调用run(),只会执行主线程
MyRunnable myRunnable1=new MyRunnable();
Thread thread1=new Thread(myRunnable1);
thread1.start();
MyRunnable myRunnable2=new MyRunnable();
Thread thread2=new Thread(myRunnable2);
thread2.start();
MyRunnable myRunnable3=new MyRunnable();
Thread thread3=new Thread(myRunnable3);
thread3.start();

}
}
/**
*
Thread-0–1
Thread-0–2
Thread-0–3
Thread-0–4
Thread-0–5
Thread-0–6
Thread-0–7
Thread-0–8
Thread-0–9
Thread-0–10
Thread-0–11
Thread-2–1
Thread-1–1
Thread-1–2
Thread-1–3
Thread-1–4
Thread-1–5
Thread-1–6
Thread-1–7
Thread-1–8
Thread-1–9
Thread-1–10
Thread-1–11
Thread-1–12
Thread-1–13
Thread-1–14
Thread-1–15
Thread-1–16
Thread-1–17
Thread-1–18
Thread-1–19
Thread-1–20
Thread-1–21
Thread-1–22
Thread-1–23
Thread-1–24
Thread-1–25
Thread-1–26
Thread-1–27
Thread-1–28
Thread-1–29
Thread-1–30
Thread-2–2
Thread-2–3
Thread-2–4
Thread-0–12
Thread-0–13
Thread-0–14
Thread-0–15
Thread-0–16
Thread-0–17
Thread-0–18
Thread-0–19
Thread-0–20
Thread-2–5
Thread-2–6
Thread-2–7
Thread-2–8
Thread-2–9
Thread-2–10
Thread-2–11
Thread-2–12
Thread-2–13
Thread-2–14
Thread-2–15
Thread-2–16
Thread-2–17
Thread-2–18
Thread-2–19
Thread-2–20
Thread-0–21
Thread-0–22
Thread-0–23
Thread-0–24
Thread-0–25
Thread-0–26
Thread-0–27
Thread-0–28
Thread-0–29
Thread-0–30
Thread-2–21
Thread-2–22
Thread-2–23
Thread-2–24
Thread-2–25
Thread-2–26
Thread-2–27
Thread-2–28
Thread-2–29
Thread-2–30

*/
*****************************************************************************************************3-2
package cn.kgc.tyl.test1010;
/**

子线程优先

*/
public class TestJoin {
public static void main(String[] args) {
//创建子线程对象
Thread thread=new Thread(new MyRunnable(), “A”);
//启动线程
thread.start();
for (int i = 0; i <20; i++) {
//当i=5时，让子线程执行完毕再执行主线程
if (i==5) {
try {
thread.join();//子线程优先
} catch (Exception e) {
e.printStackTrace();
}
}
System.out.println(Thread.currentThread().getName()+"–"+i);
}

}
}
/**
*
main–0
main–1
main–2
main–3
main–4
A–1
A–2
A–3
A–4
A–5
A–6
A–7
A–8
A–9
A–10
A–11
A–12
A–13
A–14
A–15
A–16
A–17
A–18
A–19
A–20
A–21
A–22
A–23
A–24
A–25
A–26
A–27
A–28
A–29
A–30
main–5
main–6
main–7
main–8
main–9
main–10
main–11
main–12
main–13
main–14
main–15
main–16
main–17
main–18
main–19

*/
**************************************************************************************4
package cn.kgc.tyl.test1010;

public class TestPriority {
public static void main(String[] args) {
//建立线程对象，并赋值名字
/**
*
MyRunnable myRunnable1=new MyRunnable();
Thread thread1=new Thread(myRunnable1);
thread1.setName=“a”;
* */
Thread thread1=new Thread(new MyRunnable(),“a” );
Thread thread2=new Thread(new MyRunnable(),“b” );

   //设置线程优先级[只是概率大小，不一定]；
   	thread1.setPriority(thread1.MIN_PRIORITY);
   	thread2.setPriority(thread2.MAX_PRIORITY);
	//开始执行线程
   	thread1.start();
   	thread2.start();
	
}

}
/**
*
a–1
a–2
a–3
a–4
a–5
a–6
a–7
a–8
b–1
b–2
b–3
b–4
b–5
b–6
b–7
b–8
b–9
b–10
b–11
b–12
b–13
b–14
b–15
a–9
a–10
a–11
a–12
a–13
a–14
a–15
a–16
b–16
b–17
b–18
b–19
b–20
b–21
b–22
b–23
b–24
b–25
b–26
b–27
b–28
b–29
a–17
a–18
a–19
a–20
a–21
a–22
a–23
a–24
a–25
a–26
a–27
a–28
a–29
b–30
a–30

*/
***************************************************************************************************5
package cn.kgc.tyl.test1010;

public class Wait {
public static void WaitBySeconds(Long s) {
for (int i = 1; i <=20; i++) {
System.out.println(i+“秒”);
try {
Thread.sleep(1*1000);
} catch (InterruptedException e) {

		e.printStackTrace();
	}
}

}
}
**************************************************************************************************6-1
package cn.kgc.tyl.test1010;

public class TestWait {
public static void main(String[] args) {
Wait wait=new Wait();
wait.WaitBySeconds(20L);
}
}
/**
*
1秒
2秒
3秒
4秒
5秒
6秒
7秒
8秒
9秒
10秒
11秒
12秒
13秒
14秒
15秒
16秒
17秒
18秒
19秒
20秒

*/
******************************************************************************************************6-2
package cn.kgc.tyl.test1010;

public class Yield implements Runnable{

@Override
public void run() {//重写run方法的执行方法体
	for (int i =1; i <=20; i++) {
		System.out.println("当前线程正在运行的是"+Thread.currentThread().getName()+"--"+i);
		if (i==3) {
			System.out.println("线程礼让：");
			Thread.yield();
		}
	}
}

}
********************************************************************************************7-1
package cn.kgc.tyl.test1010;

public class TestYield {
public static void main(String[] args) {
Thread t1=new Thread(new Yield(), “a”);
Thread t2=new Thread(new Yield(), “b”);
t1.start();
t2.start();
}
}

/**
*
当前线程正在运行的是a–1
当前线程正在运行的是a–2
当前线程正在运行的是a–3
线程礼让：
当前线程正在运行的是a–4
当前线程正在运行的是a–5
当前线程正在运行的是a–6
当前线程正在运行的是a–7
当前线程正在运行的是a–8
当前线程正在运行的是a–9
当前线程正在运行的是a–10
当前线程正在运行的是b–1
当前线程正在运行的是b–2
当前线程正在运行的是b–3
线程礼让：
当前线程正在运行的是b–4
当前线程正在运行的是b–5
当前线程正在运行的是b–6
当前线程正在运行的是b–7
当前线程正在运行的是b–8
当前线程正在运行的是b–9
当前线程正在运行的是b–10

*/
*********************************************************************************7-2

m0_45442261

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
集合框架之初识多线程

1、进程：在操作系统中，进程是指程序的一次完整运行。过程中内存、处理器以及IO等资源都要为其服务。当出现多个进程时，操作系统采用时间片轮转法（即同一时间段内，会有多个进程抢占资源，但在同一时间点上，只允许一个进程运行。）为进程分配相应的资源。线程：线程是进程基础上更小的划分，即在一个进程上可以创建多个线程。1-1、线程、进程的区别与联系（1）线程是比进程更快的处理单元，而且所占用的资源也小（所以多行程应用也是性能最高的应用）（2）线程与进程是相互相成的，即线程的存在离不开进程。进程消失，线程一定
复制链接

扫一扫