前提：
1：这两种方法都是通过重写run()，在run()方法中实现运行在线程上的代码
2：Runnable相比于Thread更适合多个相同程序代码去处理同一个资源的情况，通常采用Runnable
3：被synchronized 修饰的方法在某一时刻只允许一个线程访问
多线程
1.什么是线程
线程是程序执行的一条路径, 一个进程中可以包含多条线程
多线程并发执行可以提高程序的效率, 可以同时完成多项工作
2. 多线程并行和并发的区别
1) 并行就是两个任务同时运行，就是甲任务进行的同时，乙任务也在进行。(需要多核CPU)
2) 并发是指两个任务都请求运行，而处理器只能按受一个任务，就把这两个任务安排轮流进行，由于时间间隔较短，使人感觉两个任务都在运行。
3. Java程序运行原理
Java命令会启动java虚拟机，启动JVM，等于启动了一个应用程序，也就是启动了一个进程。该进程会自动启动一个“主线程” ，然后主线程去调用某个类的main 方法。
4. JVM的启动是多线程的吗
JVM启动至少启动了垃圾回收线程和主线程，所以是多线程的。
多线程程序实现的方式
1.继承Thread
* 定义类继承Thread
* 重写run方法
* 把新线程要做的事写在run方法中
* 创建线程对象
* 开启新线程, 内部会自动执行run方法
classMyThread extends Thread { //1,定义类继承Thread
public voidrun() { //2,重写run方法
for(inti = 0; i < 3000; i++) { //3,将要执行的代码,写在run方法中
System.out.println("threadrunning");
}
}
}
main:
MyThreadmt = new MyThread(); //4,创建自定义类的对象
mt.start(); //5,开启线程
for(inti = 0; i < 3000; i++) {
System.out.println("main");
}
2.实现Runnable
classMyRunnable implements Runnable { //1,自定义类实现Runnable接口
@Override
public voidrun() { //2,重写run方法
for(inti = 0; i < 3000; i++) { //3,将要执行的代码,写在run方法中
System.out.println("aaaaaaaaaaaaaaaaaaaaaaaaaaaa");
}
}
}
main:
MyRunnablemr = new MyRunnable(); //4,创建自定义类对象
//Runnabletarget = new MyRunnable();
Thread t= new Thread(mr); //5,将其当作参数传递给Thread的构造函数
t.start(); //6,开启线程
for(inti = 0; i < 3000; i++) {
System.out.println("bb");
}
两种方式的区别
* 继承Thread
* 好处是:可以直接使用Thread类中的方法,代码简单
* 弊端是:如果已经有了父类,就不能用这种方法
* 实现Runnable接口
* 好处是:即使自己定义的线程类有了父类也没关系,因为有了父类也可以实现接口,而且接口是可以多实现的
* 弊端是:不能直接使用Thread中的方法需要先获取到线程对象后,才能得到Thread的方法,代码复杂
匿名内部类实现线程的两种方式
1. 继承Thread类
new Thread() { //1,new 类(){}继承这个类
public void run() { //2,重写run方法
for(int i = 0; i< 3000; i++) { //3,将要执行的代码,写在run方法中
System.out.println("aaaaaaaaaaaaaaaaaaaaaaaaaaaa");
}
}
}.start();
2. 实现Runnable接口
new Thread(new Runnable(){ //1,new 接口(){}实现这个接口
public void run() { //2,重写run方法
for(int i = 0; i< 3000; i++) { //3,将要执行的代码,写在run方法中
System.out.println("bb");
}
}
}).start();
常用方法：
1. 获取名字和设置名字
* 1).获取名字
* 通过getName()方法获取线程对象的名字
* 2).设置名字
* setName()方法
* 通过构造函数可以传入String类型的名字
2. 获取当前线程的对象
在Runnable中不能直接使用this.getName(),可以先获取当前正在执行的线程
Thread.currentThread(),主线程也可以获取
3. 休眠线程
*Thread.sleep(毫秒,纳秒), windows支持毫秒
* 使用过程的会抛出异常，必须trycatch。
4. 礼让线程
* yield让出cpu
5. 加入线程
*join(), 当前线程暂停, 等待指定的线程执行结束后, 当前线程再继续
*join(int), 可以等待指定的毫秒之后继续
6. 设置线程的优先级
*setPriority()设置线程的优先级
同步代码块
* 1.什么情况下需要同步
* 当多线程并发, 有多段代码同时执行时, 我们希望某一段代码执行的过程中CPU不要切换到其他线程工作. 这时就需要同步.
* 如果两段代码是同步的, 那么同一时间只能执行一段,在一段代码没执行结束之前, 不会执行另外一段代码.
* 2.同步代码块
* 使用synchronized关键字加上一个锁对象来定义一段代码, 这就叫同步代码块
* 多个同步代码块如果使用相同的锁对象, 那么他们就是同步的
以火车票售票问题为例：
1. privatestatic int ticket = 10; 车票是静态的
2. 同步锁问题：
1）synchronized(this) ：new出来四个线程代表的是4个this，不是一个this。
2) Objectlock = new Object(); synchronized (obj)；4个线程，每个线程对象都有自己的成员变量lock，因此可以加static，所有对象共享同一个锁。
3. 处理：
1）synchronized(MyTicket.class),锁的是该类。
2） privatestatic Object lock = new Object(); 静态锁。
同步方法：
* 使用synchronized关键字修饰一个方法, 该方法中所有的代码都是同步的
//非静态的同步方法的锁对象是?
//答:非静态的同步方法的锁对象是this
//静态的同步方法的锁对象是什么?
//是该类的字节码对象
死锁
* 多线程同步的时候, 如果同步代码嵌套, 使用相同锁, 就有可能出现死锁
* 尽量不要嵌套使用
以前的线程安全的类
Vector,StringBuffer,Hashtable,Collections.synchroinzed(xxx)
* Vector是线程安全的,ArrayList是线程不安全的
* StringBuffer是线程安全的,StringBuilder是线程不安全的
* Hashtable是线程安全的,HashMap是线程不安全的
继承Thread类创建多线程
package rjxy;
/*
* 通过继承Thread类的方式创建两个线程，在Thread构造方法中指定线程的名字，并将这两个线程的名字打印出来。
*/
public class Thread1 {public static void main(String[] args) {
MyThread t1=new MyThread("我是线程1");
MyThread t2=new MyThread("我是线程2");
t1.start();
t2.start();
}
}
class MyThread extends Thread{
public MyThread() {
super();
}
public MyThread(String name) {
super(name);
}
public void run(){
for (int i = 0; i <10; i++) {
System.out.println(this.getName());
}
}
}
实现Runnable接口创建多线程
package rjxy;
public class Thread2 {
/*
* 通过实现Runnable接口的方式创建一个线程，要求main线程打印100次“main”，新线程打印50次“new”
*/
public static void main(String[] args) {
MyRunnable mr=new MyRunnable();
Thread t1=new Thread(mr);
t1.start();
for (int i = 0; i < 100; i++) {
System.out.println("main");
}
}
}
class MyRunnable implements Runnable{
@Override
public void run() {
for (int i = 0; i <50; i++) {
System.out.println("new");
}
}
}
一个栗子
package rjxy;
public class Thread3 {
/*
* 模拟3个来时同时分发80份笔记，每个老师相当于一个线程。
*/
public static void main(String[] args) {
MyRunnable_paper mrp=new MyRunnable_paper();
//新建是三个线程
new Thread(mrp,"赵老师").start();
new Thread(mrp,"张老师").start();
new Thread(mrp,"李老师").start();
}
}
class MyRunnable_paper implements Runnable{
private static int num=80;
@Override
public void run() {
while(true){
papers();
}
}
public synchronized void papers(){
if (num>0) {
System.out.println(Thread.currentThread().getName()+"正在发"+num--);
}else{
System.exit(0);
}
}
}
第二个栗子
package rjxy;
public class Thread4 {
// * 编写10个线程，第一个线程从1加到10， 第2个线程从11加到20，......第10个线程从91加到100，最后把10个线程的结果相加。
public static void main(String[] args) throws InterruptedException {
Thread [] mys=new Thread[10];
//多态
for (int i = 0; i < 10; i++) {
mys[i]=new MyThread_add(i*10+1);
mys[i].start();
}
for (int i = 0; i < 10; i++) {
mys[i].join();
}
System.out.println( MyThread_add.getSum());
}}
class MyThread_add extends Thread{
private int startNum;
private static int sum=0;
public MyThread_add() {
super();
// TODO Auto-generated constructor stub
}
//初始化开始值
public MyThread_add(int startNum) {
this.startNum=startNum;
}
public void run(){
int sum=0;
for (int i = 0; i <10; i++) {
sum+=startNum+i;
}
add(sum);
}
public synchronized void add(int num){
sum+=num;
}
public static int getSum(){
return sum;
}
}
第三个栗子
//窗口售票的栗子
public class Main {
public static void main(String[] args) {
MyRunnable task =new MyRunnable();//创建线程的任务类对象
new Thread(task,"窗口 1").start();//创建线程并起名
new Thread(task,"窗口 2").start();//创建线程并起名
new Thread(task,"窗口 3").start();//创建线程并起名
new Thread(task,"窗口 4").start();//创建线程并起名
}
}
class MyRunnable implements Runnable{
static private int tickets=500;//票数
@Override
public void run() {
while(true) {//无数次调用直到system.exit(0)
sendTicket();
}
}
//定义售票的方法，该方法某一时刻允许一个线程访问
public synchronized void sendTicket() {
try {
Thread.sleep(10);//线程休眠10秒
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
//售票
if (tickets>0) {
System.out.println(Thread.currentThread().getName()+"---卖出去的票"+tickets--);
}else {
System.exit(0);
}
}
}