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的区别：

比较	ArrayList	Vertor
推出时间	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的区别：

区别点	HashMap	Hashtable
推出时间	在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”结尾。

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

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

线程的生命周期：

图：线程的生命周期

---