NO.1 多线程简介
1.多线程是CPU不断在执行程序之间切换，速率极快，
给人们造成的假象是所有程序是同时执行的。 其实在内部依然是一个个执行的。
2. JVM的启动是多线程的
//证明JVM是多线程的
//创建垃圾
for (int i = 0; i < 1000000; i++){
new Test();
}
//主线程
for (int i = 0; i < 10000; i++){
System.out.println("我是主线程");
}
}
}
class Test {
@Override
public void finalize(){
System.out.println("垃圾被回收了");
}
}
NO.2 多线程实现方式(一)
MyThread mt = new MyThread();//创建线程的子类对象
// mt.run();
mt.start();//开启线程
//为了看效果，我们在主线程中也写点东西
for (int i = 0; i < 10000; i++){
System.out.println("kobekobekobe");
}
//执行后，如果是开辟了新的线程，那么这两个打印应该时交替打印的
//结果却没有，是因为我们的方法没调用好。应该是用start方法开启线程
}
}
class MyThread extends Thread {//1.继承Thread
//2.重写run方法
public void run(){
//3.将自己想执行的代码放这里面
for (int i = 0; i < 10000; i++){
System.out.println("tmactmactmac");
}
}
}
NO.3 多线程实现方式(二)
MyThread mt = new MyThread();
//Runnable接口中只有一个run方法，没有启动线程的方法，需要借助于Thread类
Thread tr = new Thread(mt); //用Thread的构造方法将实现了Runnable接口的类作为参数
tr.start();
//主线程方法
for (int i = 0; i < 10100; i++){
System.out.println("bbbbbbbbbbbbbbbbbb");
}
}
}
class MyThread implements Runnable {//1.实现Runnable接口
//2.重写run方法
public void run(){
for (int i = 0; i < 10000; i++){
System.out.println("aaaaaaaaaaaaaaaaaaaaaaaaaaa");
}
}
}
NO.4 匿名内部类实现线程的两种方式
//匿名内部类实现多线程方式一:继承Thread
new Thread() { //1.继承Thread类
public void run() {//2.重写run方法
for (int i = 0; i < 10000; i++) {
System.out.println("aaaaaaaaaaa");
}
}
}.start();//调用start方法开启线程
//主线程方法
for (int i = 0; i < 100000; i++){
System.out.println("bbbbbb");
}
// //匿名内部类实现多线程方式二:Runnable实现
//写好后将整个new Runnable作为一个参数传给Thread
new Thread(new Runnable() {
public void run(){
for (int i = 0; i < 100000; i++) {
System.out.println("cccccccccccccccccccc");
}
}
}).start();
NO.5 多线程获取名字和设置名字
//多线程取名和设置名称
//创建一条线程
//通过构造方法给线程命名
new Thread("JJ的线程") {
public void run() {
//this.getName():获取线程名
System.out.println( this.getName() + " -aaaaaaaaaaa");
}
}.start();
//创建另一条线程
new Thread("麦迪的线程") {
public void run() {
System.out.println( this.getName() + " -bbbbbb");
}
}.start();
//打印结果:Thread-0 -aaaaaaaaaaa
//Thread-1 -bbbbbb
//setName给线程取名
MyThread mr = new MyThread();
mr.setName("科比的线程");
mr.start();
}
}
class MyThread extends Thread {//1.实现Runnable接口
//2.重写run方法
public void run(){
System.out.println(this.getName() + "-ccccccc");
}
}
NO.6 获取当前线程对象
//获取当前线程
//通过构造方法给线程命名
new Thread("JJ的线程") {
public void run() {
System.out.println( this.getName() + " -aaaaaaaaaaa");
}
}.start();
//创建另一条线程
Thread tr = new Thread( new Runnable() {
public void run(){
//Thread.currentThread()就是获得当前线程
System.out.println(Thread.currentThread().getName() + "-bbbb");
}
});
tr.setName("麦迪的线程");
tr.start();
//当然也可以设置主线程名字
Thread.currentThread().setName("我是主线程");
//再打印一下主线程的线程--在主方法中调用的就是主线程
System.out.println(Thread.currentThread().getName());
NO.7 休眠线程
//休眠线程
// for (int i = 20; i >= 0; i--){
// //调用休眠方法--这里要抛出一个中断异常
// Thread.sleep(1000);//这里面传入的是毫秒值
// System.out.println("倒计时" + i + "秒");
// }
//在自己的线程中用sleep
new Thread(){
public void run(){
for (int i = 20; i >= 0; i--){
//调用休眠方法--这里要抛出一个中断异常
try {
this.sleep(1000);//这里面传入的是毫秒值
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("倒计时" + i + "秒");
}
}
}.start();
NO.8 守护线程
//守护线程:这样理解守护线程相当于象棋中的其他棋子，然后非守护线程就相当于将
//当将死亡(执行完)，那么守护线程也就得直接挂掉了
Thread t1 = new Thread() {
public void run(){
for (int i = 0; i < 2; i++){
System.out.println(this.getName() + "----111111");
}
}
};
t1.setName("t1的线程");
Thread t2 = new Thread() {
public void run(){
for (int i = 0; i < 10; i++){
System.out.println(this.getName() + "----22");
}
}
};
t2.setName("t2的线程");
//按照上面的理解，我们将t2设置为守护线程，这样当t1执行完后，t2也就随之挂掉了
t2.setDaemon(true);
t1.start();
t2.start();
NO.9 加入线程
//加入线程--相当于插队，插入的线程要先执行完了，被插入线程才能执行
final Thread t1 = new Thread() {
public void run(){
for (int i = 0; i < 10; i++){
System.out.println(this.getName() + "----111111");
}
}
};
t1.setName("t1的线程");
Thread t2 = new Thread() {
public void run(){
for (int i = 0; i < 10; i++){
if (i == 3){
try {
t1.join();//将t1线程插t2线程的执行中
//t1.join(10000);还可以指定插入线程的执行时间，过了这个时间，线程间还是交替执行
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println(this.getName() + "----22");
}
}
};
t2.setName("t2的线程");
t1.start();
t2.start();
NO.10 礼让线程
//礼让线程--只作了解
Thread t1 = new Thread() {
public void run(){
for (int i = 0; i < 500; i++){
System.out.println(this.getName() + "线程在执行");
}
}
};
MyThread mt = new MyThread();
mt.start();
t1.start();
}
}
class MyThread extends Thread {//1.实现Runnable接口
//2.重写run方法
public void run(){
for (int i = 1; i <= 1000; i++){
if (i % 10 == 0 ){
Thread.yield();//只要是10的倍数,这个线程就让出cpu
System.out.println(this.getName() + "线程在让出cpu");
}else{
System.out.println(this.getName() + "-ccccccc");
}
}
}
}
NO.11 设置线程优先级
//线程优先级
Thread t1 = new Thread() {
public void run(){
for (int i = 0; i < 10; i++){
System.out.println(this.getName() + "线程在执行");
}
}
};
Thread t2 = new Thread() {
public void run(){
for (int i = 0; i < 10; i++){
System.out.println(this.getName() + "线程在执行");
}
}
};
t1.setPriority(1);//线程优先级范围1-10之间//10最高
t2.setPriority(10);//设置优先级，不是说要一个线程执行完了，另一个线程才能执行。
//只是一个线程获得cpu的执行次数要多些而已
t2.start();
t1.start();
NO.12 线程同步代码块
//线程同步代码块:当一个线程中要执行多段代码，我们希望这个线程中正在执行的多段代码
//不要受到线程切换的影响，就需要给加一个同步代码块，这样保证一个线程中的一次执行能够完整的完成
final Printer p1 = new Printer();
//为什么这个Printer前面要有个final修饰符
//因为p1在匿名内部类中使用了，作为匿名内部类的局部变量，必须用final修饰
//创建线程
new Thread() {
public void run(){
int i = 100000000;
while (i>0){//不断调用p1中的方法
p1.print();
i--;
}
}
}.start();
new Thread() {
public void run(){
int i = 10;
while (i>0) {//不断调用p1中的方法
p1.print2();
i--;
}
}
}.start();
}
}
//打印机类
class Printer {
Test test = new Test();//所对象可以是任意的，且两个锁的对象得是一样的
public void print(){
synchronized (test){//同步代码块，锁对象:其中要传入的所对象，可以是任意的，但是不能是匿名对象
System.out.print("C");
System.out.print("罗");
System.out.print("威");
System.out.println("武");
}
}
public void print2(){
synchronized (test){
System.out.println("我是小菜鸟");
}
}
}
class Test {}
NO.13 多线程的同步方法
/**
* @param args
* 同步代码块
*/
public static void main(String[] args) {
final Printer2 p = new Printer2();
new Thread() {
public void run() {
while(true) {
p.print1();
}
}
}.start();
new Thread() {
public void run() {
while(true) {
p.print2();
}
}
}.start();
}
}
class Printer2 {
Demo d = new Demo();
//非静态的同步方法的锁对象是神马?
//答:非静态的同步方法的锁对象是this
//静态的同步方法的锁对象是什么?
//是该类的字节码对象
public static synchronized void print1() { //同步方法只需要在方法上加synchronized关键字即可
System.out.print("黑");
System.out.print("马");
System.out.print("程");
System.out.print("序");
System.out.print("员");
System.out.print("\r\n");
}
public static void print2() {
//synchronized(new Demo()) { //锁对象不能用匿名对象,因为匿名对象不是同一个对象
synchronized(Printer2.class) {
System.out.print("传");
System.out.print("智");
System.out.print("播");
System.out.print("客");
System.out.print("\r\n");
}
}
}
NO.14 线程安全问题--卖票例子
//练习铁路窗口:一共100张票，通过4个窗口卖完
//多线程并发操作同一数据时，就有可能出现线程安全问题
//使用同步技术可以解决这种问题，把操作数据的代码进行同步，不要多个线程一起操作
//开启四条线程购票
new Ticket().start();
new Ticket().start();
new Ticket().start();
new Ticket().start();
//我们这样操作，就成了每一个窗口都有100张票，各卖各的了
//我们的初衷是四个窗口共同一起卖100张票
//我们可以将这100张票弄成类变量，就成了四个对象公有的了
}
}
class Ticket extends Thread {
private static int ticket = 100;//这是100张火车票
public void run(){
synchronized (Ticket.class) {//加锁
while (true) {
if (ticket == 0) {//票卖完了,我们就跳出这个循环
System.out.println("票卖完了");
break;
}
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(this.getName() + "--这是第" + ticket-- + "号票");
}
}
}
}
NO.15 上面例子用Runnable实现
/**
* @param args
* 火车站卖票的例子用实现Runnable接口
*/
public static void main(String[] args) {
MyTicket mt = new MyTicket();
new Thread(mt).start();
new Thread(mt).start();
new Thread(mt).start();
new Thread(mt).start();
/*Thread t1 = new Thread(mt); //多次启动一个线程是非法的
t1.start();
t1.start();
t1.start();
t1.start();*/
}
}
class MyTicket implements Runnable {
private int tickets = 100;
@Override
public void run() {
while(true) {
synchronized(this) {
if(tickets <= 0) {
break;
}
try {
Thread.sleep(10); //线程1睡,线程2睡,线程3睡,线程4睡
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "...这是第" + tickets-- + "号票");
}
}
}
}
NO.16 多线程死锁
/**
* @param args
*/
private static String s1 = "筷子左";
private static String s2 = "筷子右";
public static void main(String[] args) {
new Thread() {
public void run() {
while(true) {
synchronized(s1) {
System.out.println(getName() + "...获取" + s1 + "等待" + s2);
synchronized(s2) {
System.out.println(getName() + "...拿到" + s2 + "开吃");
}
}
}
}
}.start();
new Thread() {
public void run() {
while(true) {
synchronized(s2) {
System.out.println(getName() + "...获取" + s2 + "等待" + s1);
synchronized(s1) {
System.out.println(getName() + "...拿到" + s1 + "开吃");
}
}
}
}
}.start();
}
}
