多线程的状态：
创建线程的第二种方式：实现Runnable接口
1 定义类实现Runnable接口
2 覆盖接口中的run方法，将线程的任务代码封装到run方法中
3 通过Thread类创建线程对象，并将Runnable接口的子类对象作为Thread类的构造函数的参数进行传递
为什么？因为线程的任务都封装在Runnable接口子类对象的run方法中。
所以要在线程对象创建时就必须明确要运行的任务。
4 调用线程对象的strat方法开启线程
Runnable的出现仅仅是将线程的任务进行了对象的封装。
实现Runnable接口的好处：
1 将线程的任务从线程的子类中分离出来，进行单独的封装，
按照面向对象的思想将任务封装成对象。
2 避免了java单继承的局限性
所以，创建线程的第二种方式比较常见。
class Demo implements Runnable{//准备扩展Demo类的功能，让其中的内容可以
//作为线程的任务执行，这时就需要通过接口的形式完成
public void run(){
show();
}
public void show(){
for(int x=0;x<10;x++){
System.out.println("....x="+x+"....name="+Thread.currentThread().getName());
}
}
}
public class RunnableDemo {
public static void main(String[] args) {
Demo d=new Demo();
Thread t1=new Thread(d);
Thread t2=new Thread(d);
t1.start();
t2.start();
}
}
多线程的安全问题：
线程可能会出现负数还能运行的情况，即num=0，1，-1的情况,
class Ticket implements Runnable
{
private int num=20;
public void run(){
while(true){
if(num>0){
try{//因为Runnable中run方法没有Thows，所以这里只能用try-catch。
Thread.sleep(10);//理想状态下不会出现，但是不代表不会出现，一旦出现就是致命问题，这里用sleep做停顿操作，使问题显现出来
}catch(InterruptedException e){
}
System.out.println(Thread.currentThread().getName()+"...sale..."+num--);
}
}
}
}
public class LiZi {
public static void main(String[] args) {
Ticket t=new Ticket();//创建一个线程任务对象
// Ticket tt=new Ticket();//一个对象表示一百张票
Thread t1=new Thread(t);
Thread t2=new Thread(t);
Thread t3=new Thread(t);
Thread t4=new Thread(t);
t1.start();
t2.start();
t3.start();
t4.start();
}
同步代码块：
问题出现就需要解决，如何解决呢？
解决思路：就是将多条操作共享数据的线程代码封装起来，当有线程在执行这些代码的时候，其他线程是不可以参与运算的。必须要当前线程把这些代码都执行完毕后，其他线程才可以参与运算。
而在java中用同步代码块就可以解决这个问题。
同步代码块的格式：
synchronized(对象){//这个对象就是锁
需要被同步的代码块;
}
解决：
class Ticket implements Runnable//extends Thread
{
private int num=20;
Object obj=new Object();//创建什么对象都可以
public void run(){
while(true){
synchronized(obj)//同步代码块
{
if(num>0){
try{//线程安全问题：线程可能会出现负数还能运行的情况，即num=0，1，-1的情况,
Thread.sleep(10);//理想状态下不会出现，但是不代表不会出现，一旦出现就是致命问题，这里用sleep做停顿操作，使问题显现出来
}catch(InterruptedException e){
}
System.out.println(Thread.currentThread().getName()+"...sale..."+num--);
}
}
}
}
}
public class LiZi {
public static void main(String[] args) {
Ticket t=new Ticket();//创建一个线程任务对象
// Ticket tt=new Ticket();//一个对象表示一百张票
Thread t1=new Thread(t);
Thread t2=new Thread(t);
Thread t3=new Thread(t);
Thread t4=new Thread(t);
}
同步的好处：
解决了线程的安全问题（解决了一小部分而已）。
同步的弊端：
相对降低了效率，因为同步外的线程都会判断同步锁。
同步的前提：
必须有多个线程并使用同一个锁。
不同锁的情况：
将Object obj=new Object();放进run()方法中，就形成了四个锁，一个线程一个锁。
class Ticket implements Runnable//extends Thread
{
private int num=20;
//创建什么对象都可以
public void run(){Object obj=new Object();
while(true){
synchronized(obj)//同步代码块 这里也可以直接用 Ticket.class 但最好还是obj的方式
{
if(num>0){
try{//线程安全问题：线程可能会出现负数还能运行的情况，即num=0，1，-1的情况,
Thread.sleep(10);//理想状态下不会出现，但是不代表不会出现，一旦出现就是致命问题，这里用sleep做停顿操作，使问题显现出来
}catch(InterruptedException e){
}
System.out.println(Thread.currentThread().getName()+"...sale..."+num--);
}
}
}
}
}
public class LiZi {
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();
t2.start();
t3.start();
t4.start();
}
例子：
/*
需求：储户，两个，每个都到银行存钱每次存一百，共存三次 。银行总共收到多少钱
*/
class Bank{
private int sum;//sum也是共享的
private Object obj=new Object();
public void add(int num){//找到安全隐患是在这发生的
synchronized(obj){
sum=sum+num;
try{
Thread.sleep(10);
}catch(InterruptedException e){}
System.out.println("sum="+sum);
}
}
}
class Cus implements Runnable{
private Bank d =new Bank();//d是共享的
public void run(){
// Bank d =new Bank();不可以在这里，这这里就分成了两个银行各收三百
for(int x=0;x<3;x++){
d.add(100);
}
}
}
public class TongBu {
public static void main(String[] args) {
Cus c=new Cus();
Thread t1=new Thread(c);
Thread t2=new Thread(c);
t1.start();
t2.start();
}
}
将bank类改为：
class Bank{
private int sum;//sum也是共享的
//private Object obj=new Object();
public synchronized void add(int num){//找到安全隐患是在这发生的
//synchronized(obj){
sum=sum+num;
try{
Thread.sleep(10);
}catch(InterruptedException e){}
System.out.println("sum="+sum);
//}
}
}
这里的方法叫做同步函数，效果等同于同步代码块。
同步函数使用的锁是this；
同步函数 和同步代码块的区别：
同步函数的锁是固定的this，是同步代码块的简写形式；同步代码块的锁是任意的对象。
开发时建议使用同步代码块。
class Ticket implements Runnable//extends Thread
{
private int num=100;
boolean flag=true;
public/* synchronized */void run(){
if(flag){
while(true){//这里不需要被同步,所以把if抽取到函数show里再调用
synchronized(this){//所以这里用this，控制与同步奇函数的线程用同一个锁
if(num>0){
try{
Thread.sleep(10);
}catch(InterruptedException e){
}
System.out.println(Thread.currentThread().getName()+"...daima..."+num--);
}
}
}
}
else{
while(true){
this.show();//所以同步函数的锁是this
}
}
}
public synchronized void show(){
if(num>0){
try{
Thread.sleep(10);
}catch(InterruptedException e){
}
System.out.println(Thread.currentThread().getName()+"...func..."+num--);
}
}
}
public class FuncLock {
public static void main(String[] args) {
Ticket t=new Ticket();
Thread t1=new Thread(t);
Thread t2=new Thread(t);
t1.start();
try{
Thread.sleep(10);//先暂停主线程
}catch(InterruptedException e){}
t.flag=false;
t2.start();
}
}
静态的同步函数使用的锁是 该函数所属字节码文件对象 可以用getclass()获取，也可以用 类名.class 获取 。
将Ticket类改为:
class Ticket implements Runnable//extends Thread
{
private static int num=100;
boolean flag=true;
public/* synchronized */void run(){
if(flag){
while(true){//这里不需要被同步,所以把if抽取到函数show里再调用
synchronized(this.getClass()){//因为是静态，所以要换成获取字节码文件，也可以用(Ticket.class)
if(num>0){
try{
Thread.sleep(10);
}catch(InterruptedException e){
}
System.out.println(Thread.currentThread().getName()+"...daima..."+num--);
}
}
}
}
else{
while(true){
this.show();//所以同步函数的锁是this
}
}
}
public static synchronized void show(){
if(num>0){
try{
Thread.sleep(10);
}catch(InterruptedException e){
}
System.out.println(Thread.currentThread().getName()+"...func..."+num--);
}
}
}