java-->线程总结

╰半夏微凉° 2022-06-12 02:10 215阅读 0赞

线程博客

1.  进程：  
    一块包含了某些资源的内存区域。操作系统利用进程把他的工作划分为一些功能单元。
2.  线程  
    进程中包含的一个或者多个 执行单元称为线程。一个线程是一个进程的顺序执行流，同类的多个线程共享一块内存空间和一组系统资源，线程本身有一个 供程序执行的堆栈，线程在切换时，负荷小，因此，线程被称之为轻负荷进程。
3.  联系：  
    进程还拥有一个私有的虚拟地址空间，该空间仅能被他所包含的线程访问。线程只能归属一个进程并且它只能访问该进程所拥有的资源。当操作系统创建一个进程后，该进程会自动申请一个名为主线程或首要线程的线程。操作系统上运行的每一个应用程序都运行在一个进程中，一个进程可以包含多个线程。
4.  区别：  
    一个进程至少拥有一个线程，线程的划分尺度小于进程，是的多线程的并发性高.，进程 在执行过程中拥有独立的内存单元，而多个线程共享内存，从而，极大提高了程序的运行效率。线程在执行的过程中与进程的区别在于每个独立的线程有一个程序运行的入口，顺序执行序列和程序的出口。但是线程不能独立执行必须依存在内中，由应用程序 提供多个线程执行控制。
5.  线程的使用场合：  
    线程通常用于程序中同时需要完成多个任务的情况。我们可以将每个人任务定义为一个线程，使他们一同工作。
6.  并发原理：  
    多个线程或者进程“同时”运行只是我们感官的一种表现 。事实上线程和进程是并发 执行的。os的线程的调度机制将时间划分为很多时间片段（时间片）尽可能的均匀的分配 在正在执行的程序 。获得cpu时间片的线程进程，其他则等待 。cpu在这些进程或者线程之间来回 的切换 执行。微观上所有的进程 ，线程都是走走停停。宏观上都是在运行，  
    这种都运行的 状态叫并发，但是不是绝对 意义上的并发。（之所以这样做是因为cpu只有一个，同一个时间只能做一件事随着发展 ，出现了多核cpu.例如 两核的 可以正真意义上的同时运行但是，时间片分配给线程或者进程是由线程 线程调度调度决定的。所以两个线程不一定是属于同一个进程的。）
7.  线程同步：  
    第一点：synchronized用来标识一个普通方法时，表示一个线程要执行该方法，必须取得该方法所在的对象的锁。  
    第二点：synchronized用来标识一个静态方法时，表示一个线程要执行该方法，必须获得该方法所在的类的类锁。  
    第三点：synchronized修饰一个代码块。类似这样：synchronized(obj) \{ //code…. \}。表示一个线程要执行该代码块，必须获得obj的锁。这样做的目的是减小锁的粒度，保证当不同块所需的锁不冲突时不用对整个对象加锁。利用零长度的byte数组对象做obj非常经济。

/** * 第一次,怎样创建线程 * -----------------继承Thread(派生)---并且覆盖run()方法---------- * */
     public Konw (){
    //调用父类的构造方法
    super();
    }
    // 重载run ()函数
     public void run(){
    
     }
    public static void main(String[] args) {
    //创建并初始化Konw类型对象
    Konw know=new Konw();
    //调用此方法执行创建的新线程
    know.start();
    
    
    }
    
    }
    package 线程;
    /** * * @author Carrie_zzz * */
    
    public class Konw { 
    /** * 一个系统创建单线程的例子 */
    public static void run (){
    //实现run()方法
    }
    public static void main(String []args){
    //调用静态的run()方法
    run();
    }
    }

总结:—Thread创建线程的步骤:  
(1)创建一个线程类,继承Thread类并且覆盖Thread类的run()方法..  
(2)创建一个线程类对象,创建方法与一般对象的创建相同,使用关键字new  
(3)启动新线程对象,调用start()方法  
(4)线程自己调用run()方法

package 线程;
    /** * * @author Carrie_zzz * */
    
    public class Konw implements Runnable { 
    /** * 实现Runable接口来实现 */
    
    public  void run (){
    //重载run()函数
    }
    public static void main(String []args){
    //创建并初始化类的对象
    Runnable run=new Konw();
    //通过 Thread创建线程
    Thread thread=new Thread(run);
    //启动线程
    thread.start();
    }
    }

总结:——实现Runnable线程的步骤:  
(1)创建一个实现Runnable接口的类,并且在这个类中重写run()方法  
(2)使用关键字new创建一个类 的实例  
(3)通过Runnale的实例创建一个线程对象,在创建线程对象时调用的构造函数是new Thread(类的对象),他用类中实现的run()方法作为新线程对象的run()方法.  
(4)通过调用类对象的start()方法启动线程运行  
扩展:闪屏问题:二级缓冲,在paint方法里实现,父类的,是你重写了  
/**第一步:创建一张图片**/  
Image img=createImage(getWidth(),getHeight());  
/*\* 第二步:图片上,画背景,画圆,首先拿笔 (ig)背景图片\**/  
`Graphics imag=img.getGraphics(); mag.drawImage(ig.getImage(), 0, 0, getWidth(), getHeight(), this); imag.fillOval(x,y,a,b)`

/*\* 第三步:把图片画到窗体,窗体的笔 \**/  
`g.drawImage(img,0,0,null);`

全屏:  
(1)拿到配置类,然后拿到设备类(电脑)  
(2)设置必须在,去掉系统修饰,去边框之后  
`(setUndecorated(true); getGraphicsConfiguration().getDevice().setFullScreenWindow(this);`

线程周期:  
(1)创建状态(new):创建对象后start()方法进入启动状态,调用stop方法进入停止状态  
(2)可运行状态(runnable):判断线程是否在运行1:是否处于runnable状体.2:取决于优先级和调度.  
(3)不可运行状态(non runnable):原因:线程被挂起或者发生阻塞.如:线程调用wait()函数后–可能进入阻塞状态>.调用notify或notifyAll方法  
—回到可执行状态.  
(4)退出状态(done):线程可以在任何一种状态中调用stop方法进入退出状态——-相当于线程不存在了不能反回(除此只外,执行完run会自动退出  
方法 描述 有效状态 目的状态  
start()—-开始执行一个线程——New————Runnable  
stop()—–结束执行一个线程—–New或Runnable——Done  
sleep(long)—-暂停一个时间段(毫秒)-Runnable–NonRunnable  
sleep(long,int)–暂停片刻(纳秒)—Runnable—-NonRunnable  
suspend()—-挂起执行————Runnable—NonRunnable  
resume()——恢复执行———–NonRunnable–Runnable  
yield()——明确放弃执行——–Runnable——Runnable  
wait()——-进入阻塞状态———Runnable——NonRunnable  
notify()—–阻塞状态解除———NonRunnable—Runnable  
(备注:stop(),suspend(),resume()这些方法已经不提倡使用,在虚拟机中可能引起”死锁”现象.suspend()和resume()方法的替代是wait(),sleep().线程的终止通常采用自然终止的方式,建议不要人工调用stop()).

线程状态转换:
    (1):线程进入可执行状态

1 >其他线程调用notify(),notifyAll()方法,唤起处于不可执行的线程  
Public final void notify()——>唤起一个线程,与继续获得锁  
Public final void notifyAll()—->所有等待他的  
2>:线程调用sleep(millis),millis后进入可执行状态  
Static void sleep(long millis)throw InterruptedException  
3>:线程对对IO操作的完成  
(2):线程进入不可执行状态  
1>线程自动调用wait(),等待某种状态的发生  
2>线程调用sleep()不可执行状态,  
3>线程等待IO操作的完成  
等待线程结束  
1>判断是否处于活动状态  
`Public final boolean isAlive()`  
不断查询第一个线程是否终止,没有就让住线程休眠一直到他终止  
`Start() ; While(zzz.isAlive()) { Thread.sleep(shijan); } Zz2.start();`  
2>用join()  
线程同步:  
(目的:实现共享数据的一致性)  
(1)同步概念:

*  例子:由于数据不同步而导致的错误
 *    
    
    
     *  @author Administrator
 *    
    \*/

`public class ThreadText`  
/\*\*  
\* 多线程不同步的原因  
\*  
\* @param args  
\*/

public static void main(String[] args) {
    share data = new share();// 创建初始化对象
    Thread1 thread1 = new Thread1("Thread_one", data);// 创建线程
    Thread1 thread2 = new Thread1("Thread_two", data);
    thread1.start();
    thread2.start();
    
    }
    }

class share \{  
public static String Data = “”;// 声明并初始化字符串数据域 ,让他作为共享数据域  
\}

class Thread1 extends Thread { 
    private share data;

Thread1() {
    // 声明并实现这个类的构造方法
    }
    
    Thread1(String szName, share data) {
    super(szName);// 调用父类的构造方法
    this.data = data;// 初始化data域
    }
    
    public void run() {
    for (int i = 0; i < 5; i++) {
    if (this.getName().equals("Thread_one")) {
    data.Data = "只是第一个线程";
    /** 方便演示效果,设置一次睡眠 */
    try {
    Thread.sleep((int) Math.random() * 100);
    } catch (Exception e) {
    e.printStackTrace();
    }
    System.out.println(this.getName() + ":" + data.Data);
    } else if (this.getName().equals("Thread_two")) {
    data.Data = "这是第二个线程";
    /** 同上 */
    try {
    Thread.sleep((int) Math.random() * 100);
    } catch (Exception e) {
    e.printStackTrace();
    }
    System.out.println(this.getName() + ":" + data.Data);
    }
    
    }
    }
    
    }

上面的例子是线程不同步而导致 错误.  
—————-我们用锁来解决上述问题——————-  
同步关键字:synchronized  
在一个类的方法用着关键字,叫同步方法.  
—-工具—>同步模型监视器——-  
—————<<同步格式>>———————  
(1)吧一个语句块声明为同步  
Class 类名\{  
Public synchronized 类型名称 方法名称()\{…\}  
\}  
(2)同步块  
Synchronized(对象锁)\{  
…..  
\}  
注意:锁对象得作用范围  
线程通信  
多线程之间可以通过消息 通信,达到相互协作的目的.Java中每个对象内部有对象锁还有线程等待队列(存放所有等待对象锁的线程)  
比如:(1)消费者和生产者  
(2)共享队列  
(3)运行生产者和消费者  
死锁:  
一个线程会一直处于等待另一个对象的状态,另一个对象会处于等待下一个对象的状态—–类推….等待状态链(封闭环状太)—–死锁

*  线程池：  
    当一个线程中创建大量的线程，闭关在任务结束的时候销毁 ，会给系统带来过度资源的消耗，以及过度切换线程的危险，从而可能导致系统崩溃。
 *  线程池的两个作用：  
    （1）控制线程数量  
    （2）重用线程
 *  线程池的概念：  
    首先创建一些线程，，他们的集合称为线程池，当服务器接收到一个请求后，就从线程池 中取出一个空闲的线程为之服务，服务完成后不要关闭该线程，而是将该线程还回到线程池中。  
    在线程池的编译模式下，任务是提交给整个线程池，而不是直接交给某个线程，线程池在拿到任务后，他就在内部找有无空闲的线程 ，再把任务交给内部某个空闲的线程，任务是提交给整个线程池，一个线程同时只能执行一个任务，但同时可以向一个线程池提交多个任务