线程和进程
进程
是一个独立的程序，要占用系统资源（CPU 内存）。
特点：
a. 独立性：不同的进程之间是相互独立的。数据也是不共享的。
b. 动态性：进程在系统中，运行是一个动态的。是随着系统一起运作的。
c. 并发性：多个进程（程序）可以同时在电脑中运行，互不影响。
线程
是进程的（程序）的组成部分，一个进程（程序）可以同时执行多个线程。如一个软件的多个功能。。。
线程的执行是【抢占式】。多个线程在同一个进程（程序）中运行时，会抢占当前进程的资源，CPU在不同的线程中间来回切换。切换的速度超过了肉眼识别，也就是说当一个线程执行时，其他线程会挂起等待。
java程序中，至少有两个线程，一个是main函数，另一个就是垃圾回收机制
线程和进程的区别
1、一个程序只有一个进程。
2、一个进程可以有多个线程，但是至少需要一个线程，否则进程无意义。
3、进程五共享资源，但是线程是会共享资源
4、系统打开程序（进程），需要给当前的进程（程序）分配新的对应的系统资源，效率略低。而线程的创建是进程中，不需要系统操作，所以线程的并发要比进程效率高。
5、系统打开进程（程序）没有创建线程快，操作简单，效率高一点。
线程的好处和坏处
好处：
1、可以让程序同时执行不同的任务
2、可以提高系统资源利用率
坏处：
1、线程安全问题，共享资源问题。迭代器
// 在迭代器中执行删除操作
while(it.hasNext()){
System.out.println(it.next());
list.remove(2);// 报错，因为此句和迭代器本身都是线程
}
2、增加CPU负担
3、降低其他程序的CPU执行占用率
4、容易出现死锁
创建线程的方式一
package com.thread;
/**
* 创建线程的第一种方式：
* 1、自定义线程继承类Thread类
* 2、需要【重写】Thread类内的run方法，把需要执行的自定义线程放到run方法内
*/
class MyThread extends Thread{
// 重写run方法
@Override
public void run() {
for (int i = 0; i < 10; i++) {
System.out.println("自定义线程Thread类："+i);
}
}
}
public class Demo01 {
public static void main(String[] args) {
// 1、创建自定义线程对象
MyThread mt = new MyThread();
// 2、启动线程
// mt.run();// 直接调用run方法，只是调用了一个普通方法，而不是调用了线程
mt.start();// start方法执行线程，会和其他线程抢占资源，具体表现为每次输出的顺序不定
for (int i = 0; i < 10; i++) {
System.out.println("main线程："+i);
}
}
}
线程中常用的方法
1、Thread(String name);初始化线程的名字，属于线程的一个构造方法
2、setName(String name); 设置线程的名字
3、getName(String name); 获取线程的名字
4、static sleep(int ms); 静态方法，
* 需要用Thread类名来调用的方法，让线程进入休眠状态，指定时间（毫秒）
* 【谁执行，谁休眠】
*
5、static Thread currentThread(); 静态方法
* 需要用Thread类名掉用，返回当前线程
* 【谁执行，谁返回】
*
6、setPriority(int new newPriority):设置当前线程的优先级，优先级范围是1~10，默认5
7、getPriority(); 返回当前线程的优先级，只是提高执行概率，不是百分百根据优先级执行
代码实例
package com.thread;
/**
* 线程中常用的方法
* 1、Thread(String name);初始化线程的名字，属于线程的一个构造方法
* 2、setName(String name); 设置线程的名字
* 3、getName(String name); 获取线程的名字
*
* 4、static sleep(int ms); 静态方法，
* 需要用Thread类名来调用的方法，让线程进入休眠状态，指定时间（毫秒）
* 【谁执行，谁休眠】
*
* 5、static Thread currentThread(); 静态方法
* 需要用Thread类名调用，返回当前线程
* 【谁执行，谁返回】
*
* 6、setPriority(int new newPriority):设置当前线程的优先级，优先级范围是1~10，默认5
* 7、getPriority(); 返回当前线程的优先级，只是提高执行概率，不是百分百根据优先级执行
*
* Thread[main,5,main]==
* Thread[线程名,优先级,线程组]
*/
public class Demo02 extends Thread{
/*
* super调用了父类Thread的方法
* public Thread(String name) {
init(null, null, name, 0);
}
*/
public Demo02(String name1){
super(name1);
}
// 自定义线程
@Override
public void run() {
System.out.println("自定义线程："+Thread.currentThread());
//5、static Thread currentThread();此时自定义线程线程
Thread currentThread = Thread.currentThread();
System.out.println("自定义线程："+currentThread.getName());
for (int i = 0; i <20; i++) {
System.out.println("自定义线程："+i);
/*
* 这个方法是继承而来，而父类的run方法没有抛出异常所以只能捕获，而不能抛出
* 在其他方法中，使用Thread.sleep可以捕获或者抛出异常，而run方法中，只能捕获
*
* 因为：
* 在Java语法中，重写父类的方法，要求和父类方法的声明是一致的。如：
* public static void test()
* 父类方法中，没有抛出任何异常，那么子类的方法如果出现异常，也不能抛出，只能捕获
*/
try {
Thread.sleep(500);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
public static void main(String[] args) throws InterruptedException {
// 创建自定义线程类对象
//1、Thread(String name);初始化线程的名字，属于线程的一个构造方法
Demo02 d02 = new Demo02("AAAA");
// 5、static Thread currentThread() 此时是main线程
Thread currentThread = Thread.currentThread();
// 设置优先级，只是影响执行概率，而不是真的优先
currentThread.setPriority(1);
System.out.println("当前线程："+currentThread());
System.out.println("当前线程："+currentThread.getName());
//3、getName(String name); 获取线程的名字
System.out.println(d02.getName());
//2、setName(String name); 设置线程的名字
d02.setName("BBBB");
//6、setPriority(int new newPriority):设置当前线程的优先级，优先级范围是1~10，默认5
d02.setPriority(10);
System.out.println(d02.getName());
// 启动线程不是调用run方法，而是执行start()
d02.start();
for (int i = 0; i <20; i++) {
System.out.println("main线程："+i);
Thread.sleep(500);
}
}
}
创建线程的方式二
package com.thread;
/*
* 为了解决java是一个单继承语言
* 如果继承了线程类，就不能继承其他类反之亦然
*
* 所以建议使用第二种创建线程的方法：
* 让自定义线程类【遵从】Runnable接口，实现Runnable接口中run方法，从而变成一个线程类
*
* 1、自定义遵从Runnable接口的类
* 2、实现run方法，在run方法中写线程代码
* 3、创建线程类Thread对象，把Runnbale接口的实现类作为构造方法的参数
* 4、利用Thread()的start方法
*
* 也可以简单的使用匿名内部类
*/
class TestRunnable implements Runnable{
// 实现【遵从】Runnable接口之后，一定要实现的方法
@Override
public void run() {
for (int i = 0; i < 10; i++) {
System.out.println("当前线程为："+i+" "+Thread.currentThread());
}
}
}
public class Demo03 {
public static void main(String[] args) {
TestRunnable tr = new TestRunnable();
Thread thread = new Thread(tr);
thread.start();
/*
* 匿名内部类的方法
* 利用匿名内部类的匿名对象作为Thread类的构造方法的参数，创建Thread类的匿名对象，直接调用start方法
*/
new Thread(new Runnable() {
@Override
public void run() {
for (int i = 0; i < 10; i++) {
System.out.println("匿名内部类作为方法的参数："+i);
}
}
}).start();
}
}
package com.thread;
/*
* 售票问题
*
* 卖出票后，还没有执行到 ticket--语句，会被其他线程抢去CPU执行权
* 避免资源抢占----上锁
* 【Java线程同步机制】
* 同步代码块：
* 格式：
* synchronized(锁对象){
* 加锁代码。有且只有一个线程能进入执行，直到线程执行完毕
* }
*注意事项：
* 1、锁对象可以是任意类型，但是只能是同一个对象，不能new对象，每次执行都是不同对象
* 2、sleep()不会释放锁对象，不会开锁
* 3、使用同步代码块，必须是真正意义上的线程抢占系统共享资源，同步的代码越少越好
*
*/
class SaleTicket extends Thread{
private static int ticket = 50;
public SaleTicket(String name){
super(name);
}
@Override
public void run() {
while(true){
synchronized ("锁") {
if (ticket >0){
System.out.println(Thread.currentThread().getName()+"已售出"+ticket+"张电影票");
try {
Thread.sleep(50);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}else{
System.out.println("售罄!!!");
break;
}
ticket--;
}
}
}
}
public class Demo04 {
public static void main(String[] args) {
SaleTicket s1 = new SaleTicket("淘票票");
SaleTicket s2 = new SaleTicket("猫眼");
SaleTicket s3 = new SaleTicket("糯米");
s1.start();
s2.start();
s3.start();
}
}
package com.thread;
/**
* 死锁
* 1、 存在两个或者两个以上的线程
* 2、存在两个或者灵感以上的共享资源给这些线程使用
* @author Administrator
*
*/
class DeadLock implements Runnable{
@Override
public void run() {
if(Thread.currentThread().getName().equals("小明")){
synchronized ("电池") {
System.out.println("小明拿到电池，想要遥控器");
synchronized ("遥控器") {
System.out.println("小明拿到了遥控器，开启了电视");
}
}
}else if(Thread.currentThread().getName().equals("小红")){
synchronized ("遥控器") {
System.out.println("我有遥控器，给我电池");
synchronized ("电池") {
System.out.println("小红拿到了电池，开启了电视");
}
}
}
}
}
public class Demo05 {
public static void main(String[] args) {
// TODO Auto-generated method stub
Thread t1 = new Thread(new DeadLock(),"小明");
Thread t2 = new Thread(new DeadLock(),"小红");
t1.start();
t2.start();
}
}
package com.thread;
/**
* 守护线程（后台线程）
*
* 例如：
* 软件的自动更新，软件的日志，软件的监听
*
* 特征：
* 一旦整个程序运行结束，只剩下守护线程，这个时候守护线程也会跟着销毁，因为没有意义
*
* Java了垃圾回收机制是守护线程还是普通线程
* 守护线程！！
*/
public class Demo06 extends Thread{
public Demo06(String name){
super(name);
}
@Override
public void run() {
for (int i = 0; i < 100; i++) {
System.out.println("软件下载更新中...."+i+"%");
if(i == 100){
System.out.println("下载完成，是否安装");
}
try {
Thread.sleep(100);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
public static void main(String[] args) throws InterruptedException {
Demo06 d = new Demo06("守护线程");
// 设置为守护线程
d.setDaemon(true);
d.start();
for (int i = 0; i <= 50; i++) {
Thread.sleep(100);
System.out.println("主程序："+i);
}
}
}
