线程的学习

最新推荐文章于 2024-10-11 20:26:52 发布

贝贝看见熊熊

最新推荐文章于 2024-10-11 20:26:52 发布

阅读量145

点赞数

分类专栏： Java学习文章标签： java

本文链接：https://blog.csdn.net/panchonglin/article/details/78653993

版权

Java学习专栏收录该内容

3 篇文章 0 订阅

订阅专栏

1. java中线程的几个基本概念

/**
 * 1.什么是进程？
 *      进程是指一个内存中运行的应用程序，
 *      每个进程都有自己独立的一块内存空间，
 *      一个进程中可以启动多个线程。
 *      比如在Windows系统中，
 *      一个运行的exe就是一个进程。
 * 2.线程是什么？
 *      线程是指进程中的一个执行流程，
 *      一个进程中可以运行多个线程。
 *      比如java.exe进程中可以运行很多线程。
 *      线程总是属于某个进程，
 *      进程中的多个线程共享进程的内存。     
 *      “同时”执行是人的感觉，在线程之间实际上轮换执行。
 * 3.java中的线程？
 *      1、java.lang.Thread类的一个实例；
 *      2、线程的执行。
 * /

2. java如何创建线程

 /** java如何创建一个线程？(也就是所谓的实例化线程)
 *  一：继承Thread类创建线程类
 *      1.继承 Thread类，并重写该类的run方法 ，该run方法的方法体就代表了线程要完成的任务。因此把    run()方法称为执行体。
 *      2.创建Thread子类的实例，即创建了线程对象
 *      3.调用线程对象的start()方法来启动该线程。
 *  二：通过Runnable接口创建线程类
 *      1.定义runnable接口的实现类，并重写该接口的run()方法，该run()方法的方法体同样是该线程的线程执行体。
 *      2.创建 Runnable实现类的实例，并依此实例作为Thread的target来创建Thread对象，该Thread对象才是真正的线程对象。
 *      3.调用线程对象的start()方法来启动该线程。
 *  三、通过Callable和Future创建线程
 *      1.创建Callable接口的实现类，并实现call()方法，该call()方法将作为线程执行体，并且有返回值。
 *      2.创建Callable实现类的实例，使用FutureTask类来包装Callable对象，该FutureTask对象封装了该Callable对象的call()方法的返回值。
 *      3.用FutureTask对象作为Thread对象的target创建并启动新线程。
 *      4.调用FutureTask对象的get()方法来获得子线程执行结束后的返回值
 */


/**
 * 一：继承Thread类创建线程类
 *      1.继承 Thread类，并重写该类的run方法 ，该run方法的方法体就代表了线程要完成的任务。因此把run()方法称为执行体。
 *      2.创建Thread子类的实例，即创建了线程对象
 *      3.调用线程对象的start()方法来启动该线程。
 * @author 创建线程_01
 *
 */
public class Demo01  extends Thread{
    int i = 0;
     //重写run方法，run方法的方法体就是现场执行体  
    public void run() {
         for(;i<100;i++){  
                System.out.println(getName()+"  "+i);  
          }  
    }
    public static void main(String[] args) {
         for(int i = 0;i< 100;i++)  
            {   //  Thread.currentThread()方法返回当前正在执行的线程对象
                //GetName()方法返回调用该方法的线程的名字。
                System.out.println(Thread.currentThread().getName()+"  : "+i);  
                if(i==20)  
                {  
                    //创建线程 并调用start方法
                    new Demo01().start();  
                    new Demo01().start();  
                }  
            }  
    }
}

/**
 *  二：通过Runnable接口创建线程类
 *      1.定义runnable接口的实现类，并重写该接口的run()方法，该run()方法的方法体同样是该线程的线程执行体。
 *      2.创建 Runnable实现类的实例，并依此实例作为Thread的target来创建Thread对象，该Thread对象才是真正的线程对象。
 *      3.调用线程对象的start()方法来启动该线程。
 *
 */
public class Demo01_01 implements Runnable{
    private int i;  
    //重写该接口的run()方法
    public void run() {
        for(i = 0;i <100;i++)  
        {  
            System.out.println(Thread.currentThread().getName()+" "+i);  
        }  
    }
     public static void main(String[] args)  
        {  
            for(int i = 0;i < 100;i++)  
            {  
                System.out.println(Thread.currentThread().getName()+" "+i);  
                if(i==20)  
                {  
                    Demo01_01 rtt = new Demo01_01();  
                    new Thread(rtt,"新线程1").start();  
                    new Thread(rtt,"新线程2").start();  
                }  
            }  

        }  

}


import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
/**
 *  三、通过Callable和Future创建线程
 *      1.创建Callable接口的实现类，并实现call()方法，该call()方法将作为线程执行体，并且有返回值。
 *      2.创建Callable实现类的实例，使用FutureTask类来包装Callable对象，该FutureTask对象封装了该Callable对象的call()方法的返回值。
 *      3.用FutureTask对象作为Thread对象的target创建并启动新线程。
 *      4.调用FutureTask对象的get()方法来获得子线程执行结束后的返回值
 */
public class Demo01_02 implements Callable<Integer>{

    //重写call方法
    public Integer call() throws Exception {
         int i = 0;  
            for(;i<100;i++)  
            {  
                System.out.println(Thread.currentThread().getName()+" "+i);  
            }  
            return i; 
    }

    public static void main(String[] args) {
        //创建类的对象
        Demo01_02 test = new Demo01_02();
        //用FutureTask 封装 自己写的这个类
        FutureTask<Integer> ft = new FutureTask<>(test);
        for(int i = 0;i < 100;i++)  
        {  
            System.out.println(Thread.currentThread().getName()+" 的循环变量i的值"+i);  
            if(i==20)  
            {  
                new Thread(ft,"有返回值的线程").start();  
            }  
        }  
          try  
            {  
                System.out.println("子线程的返回值："+ft.get());  
            } catch (InterruptedException e)  
            {  
                e.printStackTrace();  
            } catch (ExecutionException e)  
            {  
                e.printStackTrace();  
            }  
    }

}

3. java线程的生命周期及理解

这里写图片描述

4. 线程的同步和锁

/**
 * 1.线程的同步?
 *  是为了防止多个线程访问一个数据对象时，对数据造成的破坏。
 *  例如：两个线程ThreadA、ThreadB都操作同一个对象Foo对象，并修改Foo对象上的数据。
 *  因此才引进了一个线程同步的问题
 *  2.为什么要线程同步？ 如何解决(线程同步)
 *      我们可以在计算机上运行各种计算机软件程序。每一个运行的程序可能包括多个独立运行的线程（Thread）。 
 *      线程（Thread）是一份独立运行的程序，有自己专用的运行栈。线程有可能和其他线程共享一些资源，比如，内存，文件，数据库等。 
 *      当多个线程同时读写同一份共享资源的时候，可能会引起冲突。
 *      这时候，我们需要引入线程“同步”机制，即各位线程之间要有个先来后到，不能一窝蜂挤上去抢作一团。 
 *  3.如何实现线程同步？
 *      用关键字synchronized锁  来解决  
 *  4.什么叫做线程死锁？
 *      死锁是线程间相互等待锁锁造成的，在实际中发生的概率非常的小。
 *  真让你写个死锁程序，不一定好使，呵呵。但是，一旦程序发生死锁，程序将死掉。
 *   5.什么是线程池？
 *      放运行状态为可运行状态的线程的地方
 *
 */
/**
 * 
 * @author 创建一个票的类
 *
 */
class Piao { 
    //一共有100张票
    private  int x = 100; 

    public int getX() { 
        return x; 
    } 
    //买票方法   为了防止发上上面的现象所有加上线程同步的问题 用关键字来解决  synchronized
    public int fix(int y,String name) { 
    System.out.println(name+"卖了："+y +"张票");
        x = x - y; 
        System.out.println("还剩票 ： " + x);
        return x; 
    } 
}
/**
 * 卖票的测试
 * @author ajisuser
 *
 */
 public class Demo01_04 implements Runnable { 
    private Piao foo = new Piao(); 

    public static void main(String[] args) { 
        Demo01_04 r = new Demo01_04(); 
        Thread ta = new Thread(r, "Thread-A"); 
        Thread tb = new Thread(r, "Thread-B"); 
        ta.start(); 
        tb.start(); 
    } 

    public void run() { 
        for (int i = 0; i < 10; i++) { 
            foo.fix(5,Thread.currentThread().getName());

        } 
    } 

}