Java学习笔记(2)Java语言进阶

1、Java集合类详解


Collection接口:

  1. 集合可以理解为一个动态的对象数组,不同的是集合中的对象内容可以任意扩充。
  2. 集合的特点:1、性能高。 2、容易扩展和修改。
  3. Collection的常用子类: List Set Queue

List接口:

  1. List接口可以存放任意的数据,而且在List接口中的内容是可以重复的。
  2. List接口常用子类: ArrayList 和 Vector 。
  3. 常用操作:(1)、判断集合是否为空:Boolean isEmpty()(2)、查找指定对象是否存在:int indexOf(Object o)。若存在,返回值为元素所在位置序列号。若不存在,返回值为-1。

ArrayList与Vector的区别:

比较ArrayListVertor
推出时间JDK1.2之后推出JDK1.0推出
性能采用异步处理方式,性能高采用同步处理方法,性能低
线程安全属于非线程安全属于线程安全

例如:

package java进阶;

import java.util.ArrayList;
import java.util.List;

public class List接口 {

    public static void main(String[] args) {
        List<String> lists = null;
        lists = new ArrayList<String>();
        lists.add("A");  //添加元素
        lists.add("B");
        lists.add("A");
        for (int i = 0; i < lists.size(); i++) {
            System.out.println(lists.get(i));
        }
        lists.remove(0); //删除指定序列号元素
        System.out.println("删除之后---");
        for (int i = 0; i < lists.size(); i++) {
            System.out.println(lists.get(i));
        }
        System.out.println("集合是否为空:"+lists.isEmpty());//查看集合是否为空
        System.out.println("B是否存在:"+lists.indexOf("B"));
        //查找指定对象是否存在:int indexOf(Object o)。若存在,返回值为元素所在位置序列号。若不存在,返回值为-1。       
    }
}
程序执行结果:
  A
  B
  A
  删除之后---
  B
  A
  集合是否为空:false
  B是否存在:0 

Set接口:

  1. Set接口中不能加入重复元素,但可以排序。
  2. Set接口常用子类:(1)散列存放:HashSet。(2)有序存放:TreeSet.

例如:

package java进阶;

import java.util.HashSet;
import java.util.Set;
import java.util.TreeSet;

public class Set接口 {
    public static void main(String[] args) {
        Set<String> s = new HashSet<String>();
        s.add("E");
        s.add("A");
        s.add("D");
        s.add("C");
        s.add("B");
        System.out.println(s);//不保证按顺序存放
        TreeSet<String> s1 = new TreeSet<String>();
        s1.add("E");
        s1.add("A");
        s1.add("D");
        s1.add("C");
        s1.add("B");
        System.out.println(s1);//保证按顺序存放
    }
}

Iterator接口:

  1. 集合输出的标准操作: 标准做法,使用Iterator接口。
  2. 操作原理:Iterator是专门的迭代输出接口,迭代输出就是讲元素一个个进行判断,判断其是否有内容,如果有内容则把内容取出。

这里写图片描述

其接口下定义如下:

public interface Iterator {  
  boolean hasNext();  
  Object next();  
  void remove();  
}  

其中:

  • ​ Object next():返回迭代器刚越过的元素的引用,返回值是Object,需要强制转换成自己需要的类型
  • ​ boolean hasNext():判断容器内是否还有可供访问的元素
  • ​ void remove():删除迭代器刚越过的元素

​ 对于我们而言,我们只一般只需使用next()、hasNext()两个方法即可完成迭代。如下:

for(Iterator it = c.iterator(); it.hasNext(); ) {  
  Object o = it.next();  
   //do something  
}  

例如:

package java进阶;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class 迭代输出Iterator接口 {

    public static void main(String[] args) {
        List<String> lists = null;
        lists = new ArrayList<String>();
        lists.add("A");  //添加元素
        lists.add("B");
        lists.add("C");
        lists.add("D");
        lists.add("E");
        Iterator<String> iter = lists.iterator();//迭代接口实例化
        while (iter.hasNext()) {
            String str = iter.next();
            if("A".equals(str)) {
                iter.remove();  //删除A
            }else {
                System.out.println(str);
            }
        }
    }
}
程序执行结果:
  B C D E 

Map接口:

  • Map用于保存具有映射关系的数据(key-vlaue)。Map的key不允许重复,即同一个Map对象的任何两个key通过equals方法比较总是返回false
  • Collection 接口是保存单值最大的父接口,那么 Map接口保存的内容是一对值,所有的内容是以:key->value 的形式保存的。
  • 常用子类:(1)HashMap:无序存放,key不允许重复。(2)Hashtable:无序存放,key不允许重复.

HashMap与Hashtable的区别:

区别点HashMapHashtable
推出时间在JDK1.2之后推出的,属于新的类在JDK1.0是推出的,属于旧的类
操作采用异步的出来操作性能相对较低
性能性能高性能相对较低
安全非线程安全的操作线程安全

Map接口中定义如下方法:

方法描述
void clear()删除Map对象中所有key-value对。
boolean containsKey(Object key)查询Map中是否包含指定key,如果包含则返回true。
boolean containsValue(Object value)查询Map中是否包含一个或多个value,如果包含则返回true。
Set entrySet()返回Map中所有包含的key-value对组成的Set集合,每个集合元素都是Map.Entry(Entry是Map的内部类)对象。
Object get(Obejct key)返回指定key所对应的value;如果此Map中不包含key,则返回null。
boolean isEmpty():查询该Map是否为空(即不包含任何key-value对),如果为空则返回true。
Set keySet()返回该Map中所有key所组成的set集合。
Object put(Object key, Object value)添加一个key-value对,如果当前Map中已有一个与该key相等的key-value对,则新的key-value对会覆盖原来的key-value对。
Object remove(Object key)删除指定key对应的key-value对,返回被删除key所关联的value,如果该key不存在,返回null。
int size()返回该Map里的key-value对的个数。
Collection values()返回该Map里所有value组成的Collection。

例如:

package java进阶;

import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

public class Map接口 {

    public static void main(String[] args) {
        Map<String, String> map = new HashMap<String,String>();
        map.put("key1", "A"); //添加数据
        map.put("key2", "B");
        map.put("key3", "C");
        map.put("key4", "D");
        map.put("key5", "E");
        String str = map.get("key1");
        System.out.println(str); //通过键值找到对应值
        if (map.containsKey("key1")) {  //判断键是否存在
            System.out.println("key1存在");
        }else {
            System.out.println("key1不存在");
        } 
        if (map.containsValue("A")) {  //判断值是否存在
            System.out.println("A存在");
        }else {
            System.out.println("A不存在");
        }
        Set<String> s = map.keySet(); //将所有键打印出来
        Iterator<String> i = s.iterator();
        while (i.hasNext()) {
            System.out.println(i.next());
        }
        Collection<String> c = map.values();//将所有值打印出来
        Iterator<String> i1 = c.iterator();
        while (i1.hasNext()) {
            System.out.println(i1.next());
        }
    }
}

2、Java本地文件操作


文件的创建、重命名、删除:

package java进阶;

import java.io.File;
import java.io.IOException;

public class 文件的基本操作 {
    //文件夹结果必须处于同一分区
    //文件夹处于不同的分区,需要使用文件的拷贝。而不是重命名
    public static void main(String[] args) {
        File  file = new File("hello.txt");
        //判断文件是否存在
        if(file.exists()) {
            File nameto = new File("new hello");
            file.renameTo(nameto); //文件重命名
        }else {
            System.out.println("文件不存在");
            try {
                file.createNewFile(); //如果文件不存在创建新文件
                System.out.println("文件已经成功创建");
            } catch (IOException e) {
                System.out.println("文件无法创建");
            }
        }
        System.out.println(file.isFile());
        System.out.println(file.isDirectory());
        file.delete();
        System.out.println("文件已删除");
    }
}

文件夹的创建、重命名、删除:

package java进阶;
import java.io.File;
public class 文件夹的基本操作 {
    public static void main(String[] args) {
        File folder = new File("my new folder/two/three/main");
        if (folder.mkdirs()) {
            System.out.println("文件夹创建成功");
        }else {
            if (folder.exists()) {
                System.out.println("文件夹已经存在无需创建");
            }else {
                System.out.println("文件创建失败");
            }
        }
        File newfolder = new File("my new folder-new/one/two");
        if (folder.renameTo(newfolder)) {
            System.out.println("文件夹重命名成功");
        }else {
            if (newfolder.exists()) {
                System.out.println("文件夹已经重命名成功");
            }else {
                System.out.println("文件夹重命名失败");
            }
        }
        //只能删除空文件夹
        if (newfolder.delete()) {
            System.out.println("文件夹删除成功");  
        }else {
            System.out.println("文件夹删除失败");
        }           
    }
}

获取文件的属性:

package java进阶;
import java.awt.geom.FlatteningPathIterator;
import java.io.File
public class 获取文件属性 {
    public static void main(String[] args) {
        File file = new File("new hello");
//      判断文是否存在
        System.out.println("判断文是否存在:"+file.exists());
//      读取文件名称
        System.out.println("读取文件名称:"+file.getName());
//      读取文件路径
        System.out.println("读取文件路径:"+file.getPath());
//      读取文件绝对路径
        System.out.println("读取文件绝对路径:"+file.getAbsolutePath());
//      读取文件父级路径
        System.out.println("读取文件父级路径:"+ new File(file.getAbsoluteFile().getParent()));
//      读取文件大小
        System.out.println("读取文件大小:"+ file.length()+"Byte");
//      判断文件是否被隐藏
        System.out.println("判断文件是否被隐藏:"+file.isHidden());
//      判断文件是否可写
        System.out.println("判断文件是否可写:"+file.canWrite());
//      判断文件是否可读
        System.out.println("判断文件是否可读:"+file.canRead());
//      判断文件是否为文件夹
        System.out.println("判断文件是否为文件夹:"+file.isDirectory());
    }
}

程序执行结果:
  判断文是否存在:true
  读取文件名称:new hello
  读取文件路径:new hello
  读取文件绝对路径:D:\我的软件\eclipse\java学习\new     hello
  读取文件父级路径:D:\我的软件\eclipse\java学习
  读取文件大小:21Byte
  判断文件是否被隐藏:false
  判断文件是否可写:true
  判断文件是否可读:true
  判断文件是否为文件夹:false

文件属性的设置:

package java进阶;
import java.io.File;
public class 文件属性的设置 {
    public static void main(String[] args) {
        File file = new File("new hello");
        if (file.exists()) {
            //将文件设置为可写
            file.setWritable(true);
            //将文件设置为可读
            file.setReadable(true);
            //将文件设置为只读
            file.setReadOnly();
        }
    }
}

文件的遍历:

package java进阶;
import java.io.File;
public class 文件的遍历 {
    public static void main(String[] args) {
        printFiles(new File("../java学习"),1);
    }
    public static void printFiles(File dir,int tab) {
        if (dir.isDirectory()) {
            File next[] = dir.listFiles();  //返回文件的目录文件名数组
            for (int i = 0; i < next.length; i++) {
                for (int j = 0; j < tab; j++) {
                    System.out.print("|---");
                }
                System.out.println(next[i].getName());
                if (next[i].isDirectory()) {
                    printFiles(next[i],tab+1);
                }
            }
        }
    }
}

程序执行结果:

|---.classpath
|---.project
|---.settings
|---|---org.eclipse.jdt.core.prefs
|---bin
|---|---java基础
|---|---|---stringBuffer.class
|---|---|---Switch开关语句.class
|---|---|---字符串操作.class
|---|---|---异常处理.class
|---|---|---找最大数.class
|---|---|---控制台输入.class
|---|---|---数组排序.class
|---|---|---逻辑运算.class
|---|---java进阶
|---|---|---List接口.class
|---|---|---Map接口.class
|---|---|---Set接口.class
|---|---|---文件夹的基本操作.class
|---|---|---文件属性的设置.class
|---|---|---文件的基本操作.class
|---|---|---文件的遍历.class
|---|---|---获取文件属性.class
|---|---|---迭代输出Iterator接口.class
|---|---java面向对象
|---|---|---A.class
|---|---|---A1.class
|---|---|---A2.class
|---|---|---Abs.class
|---|---|---Abs3.class
|---|---|---B.class
|---|---|---B1.class
|---|---|---B2.class
|---|---|---C.class
|---|---|---C1.class
|---|---|---Computer.class
|---|---|---D.class
|---|---|---Father.class
|---|---|---Gener.class
|---|---|---Generic.class
|---|---|---Gin.class
|---|---|---I.class
|---|---|---Ineter1.class
|---|---|---instanceof关键字.class
|---|---|---Inter2.class
|---|---|---Inter3.class
|---|---|---Interface.class
|---|---|---J.class
|---|---|---People.class
|---|---|---People1.class
|---|---|---People2.class
|---|---|---People3.class
|---|---|---Person.class
|---|---|---Person1.class
|---|---|---PetWorker.class
|---|---|---Point.class
|---|---|---Printer.class
|---|---|---Ref.class
|---|---|---Son.class
|---|---|---Student.class
|---|---|---Student1.class
|---|---|---Student2.class
|---|---|---this关键字.class
|---|---|---USB.class
|---|---|---USBDesk.class
|---|---|---Worker.class
|---|---|---Worker2.class
|---|---|---匿名对象.class
|---|---|---多态性.class
|---|---|---子类对象的实例化.class
|---|---|---对象多态性的应用.class
|---|---|---封装性.class
|---|---|---引用传递.class
|---|---|---抽象类.class
|---|---|---抽象类的应用.class
|---|---|---接口的实现.class
|---|---|---接口的应用.class
|---|---|---构造方法.class
|---|---|---构造方法中使用泛型.class
|---|---|---泛型接口.class
|---|---|---泛型数组.class
|---|---|---泛型方法.class
|---|---|---继承.class
|---|---|---继承方法的重写.class
|---|---|---继承的限制.class
|---|---|---认识泛型.class
|---|---|---递归调用.class
|---my new folder
|---|---one
|---|---|---two
|---|---|---|---three
|---|---|---|---|---main
|---|---two
|---|---|---three
|---|---|---|---main
|---my new folder-new
|---|---one
|---new hello
|---src
|---|---java基础
|---|---|---stringBuffer.java
|---|---|---Switch开关语句.java
|---|---|---字符串操作.java
|---|---|---异常处理.java
|---|---|---找最大数.java
|---|---|---控制台输入.java
|---|---|---数组排序.java
|---|---|---逻辑运算.java
|---|---java进阶
|---|---|---List接口.java
|---|---|---Map接口.java
|---|---|---Set接口.java
|---|---|---文件夹的基本操作.java
|---|---|---文件属性的设置.java
|---|---|---文件的基本操作.java
|---|---|---文件的遍历.java
|---|---|---获取文件属性.java
|---|---|---迭代输出Iterator接口.java
|---|---java面向对象
|---|---|---instanceof关键字.java
|---|---|---this关键字.java
|---|---|---匿名对象.java
|---|---|---多态性.java
|---|---|---子类对象的实例化.java
|---|---|---对象多态性的应用.java
|---|---|---封装性.java
|---|---|---引用传递.java
|---|---|---抽象类.java
|---|---|---抽象类的应用.java
|---|---|---接口的实现.java
|---|---|---接口的应用.java
|---|---|---构造方法.java
|---|---|---构造方法中使用泛型.java
|---|---|---泛型接口.java
|---|---|---泛型数组.java
|---|---|---泛型方法.java
|---|---|---继承.java
|---|---|---继承方法的重写.java
|---|---|---继承的限制.java
|---|---|---认识泛型.java
|---|---|---递归调用.java

文件的简单读写:

package java进阶;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.UnsupportedEncodingException;

public class 文件的简单读写 {

    public static void main(String[] args) {
        File file = new File("hello word");
        //如果文件不存在,文件输出流会自动创建文件
        //写文件
        try {
            FileOutputStream fos = new FileOutputStream(file); //创建文件输出流
            OutputStreamWriter osw = new OutputStreamWriter(fos,"UTF-8");//创建输出流
            BufferedWriter bw = new BufferedWriter(osw); //创建缓冲区的write
            bw.write("hello word!\n");//向文件写入“hello word!”
            bw.close();//关闭流
            osw.close();
            fos.close();    
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
        //读取文件
        try {
            FileInputStream fis = new FileInputStream(file);
            InputStreamReader isr = new InputStreamReader(fis, "UTF-8");
            BufferedReader br = new BufferedReader(isr);
            String list;  //定义一个变量用于存放读取的数据
            while ((list = br.readLine()) != null) {
                System.out.println(list);
            }
            br.close();
            isr.close();
            fis.close();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }           
    }
}
程序执行结果:
  hello word!

3、Java中的IO操作


Java IO简介:

  • IO也写作“I/O”,可理解为In和Out,即输入与输出。所有,IO体系的基本功能就是:读和写。
  • IO流作用:读写设备上的数据,硬盘文件、内存、键盘、网络···
  • 根据数据的走向,可以分为:输入流、输出流。
  • 根据处理的数据类型,可分为:字节流、字符流。

字节流与字符流:

  • 字节流可以处理所有类型的数据,如MP3、图片、文字、视频等。在读取时,读到一个字节就返回一个字节。在Java中对应的类都以“Stream”结尾。
  • 字符流仅能够处理纯文本数据,如txt文本等。在读取时,读到一个或多个字节,先查找指定的编码表,然后将查到的字符返回。在Java中对应的类都以“Reader”或“Writer”结尾。

字符、字节与编码的区别:

说明举例
字符人们使用的记号,抽象意义上的一个符号。
字节计算机中的存储数据的单元,一个8位的二进制大数,是一个很具体的存储空间。
ANSI编码系统预设的标准文字存储格式,不是具体的某一种编码,不同的国家和地区使用不同的标准。ANSI编码的一个字符可能使用一个字节或多个字节来表示。
Unicode编码为了是国际间信息交流更加方便,国际组织制定了Unicode字符集,为各种语言中的每一个字符设定了统一并且唯一的数字编码,以满足跨语言、跨平台进行文本转换、处理的要求。
字符集(Charset)字符集,也称作“编码”。

使用文件流读写文件:

package java进阶;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

public class 使用字节流读写数据 {
    public static void main(String[] args) {
        try {
            FileOutputStream fos = new FileOutputStream("hello word1");
            FileInputStream fis = new FileInputStream("hello word");
            byte input[] = new byte[30]; //定义读取文件存放位置
            fis.read(input);   //读文件
            String inputString = new String(input);
            System.out.println(inputString);//输出文件内容
            fos.write(input);  //写入新的文件,实现文件的复制
            fos.close();  //关闭流
            fis.close();    
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

4、Java多线程编程:


线程与进程:

  • 线程:程序中单独顺序的控制流。特点:(1)线程本身依靠程序进行运行。(2)线程是程序中的顺序控制流,只能使用分配给程序的资源和环境。
  • 进程:执行中的程序。(1)一个进程可以包含一个或多个线程。(2)一个进程至少要包含一个线程。
  • 单线程:程序中只存在一个线程,实际上主方法就是一个主线程。
  • 多线程:(1)多线程是一个程序中运行多个任务。(2)多线程的母的是为了更好的使用CPU资源。

线程的实现:

  1. 在Java中,线程的实现有2种。(1)继承Thread类。(2)实现Runnable接口。

  2. Thread类:是在Java.lang包中定义的,继承Thread类必须重写run()方法。定义格式:

  3. class className extends Thread{
       run(){};
    }
  4. Runnable接口

例如:

通过继承Thread类实现线程:

package java进阶;
//通过继承Thread类实现线程
public class MyThread extends Thread{
    private String name;
    public MyThread(String name) {   //构造方法用于传参
        this.name = name;
    }
    public void run() {
        for (int i = 0; i < 1000; i++) {
            System.out.println(name+":"+i);
        }
        super.run();
    }
}

通过Runnable接口实现线程:

package java进阶;
//通过Runnable接口实现线程
public class MyRunnable implements Runnable{
    private String name;
    public MyRunnable(String name) {
        this.name = name;
    }
    public void run() {
        for (int i = 0; i < 1000; i++) {
            System.out.println(name+":"+i);
        }
    }
}

用过主函数调用方法:

package java进阶;

public class 线程主函数 {
    public static void main(String[] args) {

        //通过Thread方法实现线程
        MyThread t1 = new MyThread("A");
        MyThread t2 = new MyThread("B");
        t1.start(); //线程的启动时通过start
        t2.start();

        //通过Runnable实现线程
        MyRunnable r1 = new MyRunnable("C");
        MyRunnable r2 = new MyRunnable("D");
        Thread t3 = new Thread(r1);
        Thread t4 = new Thread(r2);
        t3.start();
        t4.start();
    }
}

线程的状态:

线程有固定的操作状态:

  • 创建状态:准备好了一个多线程的对象。
  • 就绪状态:调用start()方法,等待CPU进行调度。
  • 运行状态:执行run()方法。
  • 阻塞状态:暂时停止执行,可能将资源交给其他线程使用。
  • 终止状态(死亡状态): 线程销毁。

线程的常用方法:

  1. 取得线程名称:getName();
  2. 取得当前线程对象:currentThread();
  3. 判断线程是否启动:isAlive();
  4. 线程的强行运行:join();
  5. 线程的休眠:sleep();
  6. 线程的礼让:yield();

例如:

package java进阶;

class Thread1 extends Thread{
    private String name;
    public Thread1(String name) {
        this.name = name;
    }
    public void run() {
        for (int i = 0; i < 50; i++) {
            System.out.println(name+":"+i);
            if (i == 10) {
                System.out.println("礼让");
                Thread.yield();
            }
            try {
                Thread.sleep(10); //线程的休眠
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        //取得当前线程对象
        System.out.println(Thread.currentThread());
        //取得当前线程名称
        System.out.println(Thread.currentThread().getName());
        super.run();
    }
}
public class 线程的常用方法 {

    public static void main(String[] args) {
        Thread1 t1 =new  Thread1("A");
        Thread1 t2 =new  Thread1("B");
        //判断线程是否启动
        System.out.println(t1.isAlive());
        t1.start();
        for (int i = 0; i < 50; i++) {
            if (i > 10) {
                try {
                    t1.join(); //线程的强制执行
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println("主线程:"+i);
        }
        t2.start();
        System.out.println(t1.isAlive());
    }
}

线程优先级:

  • MIN_Priority—1
  • MAX_Priority—10
  • NORM——Priority—5. 默认值为5

  • 注意:线程优先级不是一定按优先级执行。而是提高了执行概率。

t1.setPtiority(Thread.MIN_PRIOITY);

同步与死锁:

  1. 同步代码块:在代码块上加上“synchronized”关键字,则此代码块就称为同步代码块。

  2. 同步代码块格式:

  3. synchronized(同步对象){
     需要同步的代码块;
    }
  4. 同步方法:除了代码块可以同步,方法也可以同步。

  5. 方法同步的格式:synchronized void 方法名称(){}

  6. 同步实现了资源的共享。

死锁:死锁是两个甚至多个线程被永久阻塞时的一种运行局面,这种局面的生成伴随着至少两个线程和两个或者多个资源。

package java进阶;
//三个窗口卖一辆车的车票,实现数据的同步
class Synchornized implements Runnable{
    private int ticket = 5;
    public void run() {
        for (int i = 0; i < 10; i++) {
        tell();
        }
    }
    public synchronized void tell() {  //同步方法
        if(ticket > 0) {
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("ticket:" + ticket-- );
        }
    }
}
public class 线程的同步 {

    public static void main(String[] args) {
        Synchornized s = new Synchornized();
        Thread t1 = new Thread(s);
        Thread t2 = new Thread(s);
        Thread t3 = new Thread(s);
        t1.start();
        t2.start();
        t3.start();
    }
}

线程的生命周期:

这里写图片描述

图:线程的生命周期


已标记关键词 清除标记
相关推荐
©️2020 CSDN 皮肤主题: 技术工厂 设计师:CSDN官方博客 返回首页