--------------------- android培训、java培训、期待与您交流！ ----------------------
一丶多线程概述
1、进程：是一个正在执行中的程序。每一个进程执行，都有一个执行的顺序，该顺序是一个执行路径，或者叫一个控制单元。
2、线程：是进程中一个独立的控制单元，线程在控制着进程的执行。
3、一个进程中至少有一个线程。
4、JVM启动的时候会有一个进程java.exe。该进程中至少有一个进程负责java程序的执行，而且该线程运行的代码存在于main方法 中。该线程称之为主线程。
5、JVM启动不止一个线程，还有垃圾回收机制的线程。
二丶创建多线程-继承Thread类
1、创建线程两种方法（查找API可知）
2、第一种方法：继承Thread类。
/*
1.定义类继承Thread
2.复写Thread类中的run方法
3.调用线程的start方法，该方法有两个作用：
﹂启动线程，调用run方法。
4.运行结果每次都不一样，因为多个线程都获取cpu的执行权，cpu执行到谁，谁就运行。
在某一个时刻，只能有一个程序在运行(多核除外)。
cpu在做着快速切换，达到看上去是同时运行的效果。这就是多线程的一个特性：随机性。
*/
class Demo extends Thread
{
public void run()
{
for (int x=0;x<60;x++)
System.out.println("demo run--"+x);
}
}
class ThreadDemo
{
public static void main(String[] args)
{
Demo d=new Demo();//创建一个线程
d.start();//开启线程并执行该线程的run方法
//d.run();//仅仅是对象调用方法，而线程创建了，并没有执行。
for(int x=0;x<60;x++)
System.out.println("Hello World!--"+x);
}
}|--Thread类用于描述线程，该类就定义了一个功能，用于存储线程要运行的代码，改存储功能就是run方法。
|--也就是说Thread类中的run方法，用于存储线程要运行的代码。
|--目的是将自定义代码存储在run方法，让线程运行。
4、线程练习
/*
创建2个线程，和主线程交替运行。
*/
class Test extends Thread
{
//private String name;
Test(String name)
{
//his.name=name;
super(name);
}
public void run()
{
for(int x=0;x<60;x++)
{
System.out.println(this.getName()+"test run..."+x);
}
}
}
class ThreadTest
{
public static void main(String[] args)
{
Test t1=new Test("one-");
Test t2=new Test("two-");
t1.start();
t2.start();
for(int x=0;x<60;x++)
{
System.out.println("main run..."+x);
}
}
}6、售票示例
/*
需求：买票程序
多个窗口同时买票
*/
class Ticket extends Thread
{
private static int tick=100;//一般不使用静态，静态周期太长
public void run()
{
while(true)
{
if(tick>0)
{
System.out.println(Thread.currentThread().getName()+"....sale:"+tick--);
}
}
}
}
class TicketDemo
{
public static void main(String[] args)
{
Ticket t1=new Ticket();
Ticket t2=new Ticket();
Ticket t3=new Ticket();
Ticket t4=new Ticket();
t1.start();
t2.start();
t3.start();
t4.start();
}
}
三丶创建线程-实现Runnable接口
1、创建线程的第二种方法。
/*
需求：买票程序
多个窗口同时买票
1.定义类实现Runnable接口
2.覆盖Runnable接口中的run方法
﹂将线程要运行的代码存放在该run方法中
3.通过Thread类建立线程对象
4.将Runnable接口的子类对象作为实际参数传递给Thread类的构造函数
﹂为什么将Runnable接口的子类对象传递给Thread的构造函数？
﹂因为自定义的run方法所属的对象是Runnable接口的子类对象，
﹂所以要让线程去指定对象的run方法，就必须明确该run方法所属的对象
5.调用Thread类的start方法开启线程并调用Runnable接口子类的run方法
*/
class Ticket implements Runnable
{
private int tick=100;
public void run()
{
while(true)
{
if(tick>0)
{
System.out.println(Thread.currentThread().getName()+"....sale:"+tick--);
}
}
}
}
class TicketDemo
{
public static void main(String[] args)
{
Ticket t=new Ticket();
Thread t1=new Thread();
Thread t2=new Thread();
Thread t3=new Thread();
Thread t4=new Thread();
t1.start();
t2.start();
t3.start();
t4.start();
}
}﹂实现方式避免了单继承的局限性。
﹂建议定义线程时，使用实现方式。
|--继承Thread：线程代码存放在Thread子类run方法中。
|--实现Runnable：线程代码存放在接口的子类的run方法中。
四丶多线程的安全问题
1、当多条语句在操作同一个线程共享数据时，一个线程对多条语句只执行了一部分，还没有执行完成
﹂另一个线程参与进来执行，导致共享数据的错误。
2、解决方法：
|--对多条操作共享数据的语句，只能让一个线程都执行完，在执行过程中，其他线程不可以参与执行。
3、java对于多线程的安全问提供了专业的就解决方式。就是同步代码块。
synchronized(对象)
{
需要被同步的代码
}
五丶同步代码块
/*
synchronized(对象)
{
需要被同步的代码
}
对象如同锁，持有锁的线程可以在同步中执行，没有持有锁的线程
即使获取cpu的执行权，也进不去，因为没有获取锁
同步的前提：
1.必须要有两个或者两个以上的线程
2.必须是多个线程使用同一个锁
弊端：多个线程需要判断锁，较为消耗资源
*/
六丶同步函数
/*
需求：银行有一个金库。有两个储户分别存300元，每次存100，存三次。
目的：改程序是否有安全问题，如果有，怎么解决。
如何找到问题：
1.明确那些代码是多线程运行代码。
2.明确共享数据。
3.明确多线程运行代码中那些语句是操作共享数据的。
*/
class Bank
{
private int sum;
// Object obj=new Object();
public synchronized void add(int n)
{
// synchronized(obj)
// {
sum=sum+n;
try
{
Thread.sleep(10);
}
catch(Exception e)
{
}
System.out.println("sum"+sum);
// }
}
}
class Cus implements Runnable
{
private Bank b=new Bank();
public void run()
{
for (int x=0;x<3;x++)
{
b.add(100);
}
}
}
class BankDemo()
{
public static void main(String[] args)
{
Cus c=new Cus();
Thread t1=new Thread();
Thread t2=new Thread();
t1.start();
t2.start();
}
}
============================================================================================
/*
同步函数用的是哪一个锁？
函数需要被对象调用，那么函数都有一个所属的对象引用，就是this。
所以同步函数使用的锁匙this。
通过该程序进行验证：
使用两个线程来卖票
一个线程在同步代码块中
一个线程在同步函数中
都在执行卖票动作
如果同步说明没有错误的票
----------------------------------------------------------------
静态同步函数的琐是class对象
静态进内存，内存中没有本类对象，但是一定有该类对应的字节码文件对象。
类名.class 该类对象的类型是class
*/
class Ticket implements Runnable
{
private int tick=100;
Object obj=new Object();
boolean flag=true;
public void run()
{
if(flag)
{
while(true)
{
// show();
synchronized(this)
{
if(tick>0)
{
try
{
Thread.sleep(10);
}
catch(Exception e)
{
}
System.out.println(Thread.currentThread().getName()+"....code:"+tick--);
}
}
}
}
else
while(true)
show();
}
public synchronized void show()//this
{
if(tick>0)
{
try
{
Thread.sleep(10);
}
catch(Exception e)
{
}
System.out.println(Thread.currentThread().getName()+"....show:"+tick--);
}
}
}
class TicketDemo
{
public static void main(String[] args)
{
Ticket t=new Ticket();
Thread t1=new Thread(t);
Thread t2=new Thread(t);
// Thread t3=new Thread(t);
// Thread t4=new Thread(t);
t1.start();
try
{
Thread.sleep(10);
}
catch(Exception e)
{
}
t.flag=false;
t2.start();
// t3.start();
// t4.start();
}
}七丶线程间通讯-示例代码
1、其实就是多个线程在操作同一个资源，但是操作的动作不同。
/*
wait,notify(),notifyAll()都使用在同步中，因为要对持有监视器（锁）的线程操作。
所以要使用在同步中，因为只有同步才具有锁。
为什么这些操作线程的方法要定义在Object类中呢？
因为这些方法在操作同步中线程时，都必须要标识他们所操作线程只有的锁，
只有同一个锁上的被等待线程，可以被通一通锁上notify唤醒。
不可以对不同锁中的线程进行唤醒。
也就是说，等待和唤醒必须是同一个锁。
而锁可以是任意对象，所以可以被任意对象调用的方法定义在Object类中。
*/
class Res
{
private String name;
private String sex;
private boolean flag=false;
public synchronized void set(String name,String sex)
{
if(flag)
try
{
this.wait();
}
catch(Exception e)
{
}
this.name=name;
this.sex=sex;
flag=true;
notify();
}
public synchronized void out()
{
if(!flag)
try
{
this.wait();
}
catch(Exception e)
{
}
System.out.println(name+"......"+sex);
flag=flase;
notify();
}
}
class Input implements Runnable
{
private Res r;
// Object obj=new Object();
Input(Res r)
{
this.r=r;
}
public void run()
{
int x=0;
while(true)
{
/* synchronized(r)
{
if(r.flag)
try
{
r.wait();
}
catch(Exception e)
{
}
*/
if(x==0)
{
// r.name="mike";
// r.sex="man";
r.set("mike","man");
}
else
{
// r.name="丽丽";
// r.sex="女";
r.set("丽丽","女");
}
x=(x+1)%2;
// r.flag=true;
// r.notify();//唤醒
}
}
}
}
class Output implements Runnable
{
private Res r;
// Object obj=new Object();
Output(Res r)
{
this.r=r;
}
public void run()
{
while(true)
{
/* synchronized(r)
{
if(!r.flag)
try
{
r.wait();
}
catch(Exception e)
{
} */
r.out();
// System.out.println(r.name+"......"+r.sex);
// r.flag=false;
// r.notify();
}
}
}
}
class InputOutputDemo
{
public static void main(String[] args)
{
Res r=new Res();
new Thread(new Input(r)).start();
new Thread(new Output(r)).start();
/* Input in=new Input(r);
Output out=new Output(r);
Thread t1=new Thread(in);
Thread t2=new Thread(out);
t1.start();
t2.start(); */
}
}
八丶停止线程
/*
stop方法已经过时，那么如何停止线程？
只有一种，run方法结束。
开启多线程运行，运行代码通常是循环结构，只要控制循环，就可以让run方法
结束，也就是线程结束。
特殊状况：
当线程处于了冻结状态，就不会读取到标记，那么线程就不会结束
当没有指定的方式让冻结的线程恢复到运行状态时，这时需要对冻结进行清除，
强制让线程恢复到运行状态中来，这样就可以操作标记让线程结束。
Thread类提供的方法interrupt();
*/
class StopThread implements Runnable
{
private boolean flag=true;
public synchronized void run()
{
// while(flag)
{
try
{
wait();
}
catch(interruptedException e)
{
System.out.println(Thread.currentThread().getName()+"......Exception");
flag=false;
}
System.out.println(Thread.currentThread().getName()+"...run");
}
}
public void changeFlag()
{
flag=false;
}
}
class StopThreadDemo
{
public static void main(String[] args)
{
StopThread st=new StopThread();
Thread t1=new Thread();
Thread t2=new Thread();
t1.start();
t2.start();
int num=0;
while(true)
{
if(num++==60)
{
// st.changeFlag();
t1.interrupt();
t2.interrupt();
break;
}
System.out.println(Thread.currentThread().getName()+"......"+num);
}
System.out.println("over");
}
}九丶守护线程
1、守护线程就是后台线程，后台线程不用刻意结束，前台线程完成后，自动结束。
--------------------- android培训、java培训、期待与您交流！ ----------------------
801
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
