volatile

鎖定

XBYTE[2]=0x55;
XBYTE[2]=0x56;
XBYTE[2]=0x57;
XBYTE[2]=0x58;

int square(volatile int *ptr)
{
    return ((*ptr) * (*ptr));
}

int square(volatile int* &ptr)//這裏參數應該申明為引用，不然函數體裏只會使用副本，外部沒法更改
{
    int a,b;
    a = *ptr;
    b = *ptr;
    return a*b;
}

long square(volatile int*ptr)
{
    int a;
    a = *ptr;
    return a*a;
}

volatile int vint;

volatile int i=10;
int a=i;
//...

int b=i;

#include<stdio.h>

void main(int argc,char *argv[])

{
    
    int i = 10;
    
    int a = i;
    
    printf("i=%d",a);
    //下面彙編語句的作用就是改變內存中i的值，但是又不讓編譯器知道
    __asm
    {
        mov dword ptr[ebp-4],20h
    }
    int b = i;
    printf("i=%d",b);
}

#include<stdio.h>
void main(int argc,char *argv[])
{
    volatile int i = 10;
    int a = i;
    printf("i=%d",a);
    __asm
    {
    `    mov dword ptr[ebp-4],20h
    }
    int b = i;
    printf("i=%d",b);
}

for(int i=0; i<100000; i++);

for(volatile int i=0; i<100000; i++);

static int i = 0;
int main(void)
{
    //...
    while(1)
    {
        if(i)
            dosomething();
    }
}
/*Interruptserviceroutine.*/
void ISR_2(void)
{
    i=1;
}

class Gadget
{
    public:
        void Wait()
        {
            while(!flag_)
            {
                Sleep（1000);//sleeps for 1000milli seconds
            }
        }
        void Wakeup()
        {
            flag_=true;
        }
        //...
    private:
        bool flag_;
};

class Gadget
{
    public:
        //...as above...
    private:
        volatile bool flag_;
};

@NotThreadSafe
public class NumberRange{
    private int lower,upper;
    public int getLower(){
        return lower;
    }
    public int getUpper(){
        return upper;
    }
    public void setLower(int value){
        if(value > upper) throw new IllegalArgumentException(...);
        lower = value;
    }
    public void setUpper(int value){
        if(value < lower) throw new IllegalArgumentException(...);
        upper = value;
    }
}

volatile boolean shutdownRequested;
...
public void shutdown()
{
    shutdownRequested=true;
}
public void doWork()
{
    while(!shutdownRequested)
    {
        //dostuff
    }
}

public class BackgroundFloobleLoader{
    public volatile Flooble theFlooble;
    public void initInBackground(){
        //dolotsofstuff
        theFlooble = newFlooble();
        //this is the only write to theFlooble
    }
}
public class SomeOtherClass{
    public void doWork(){
        while(true){
            //dosomestuff...
            //usetheFlooble,butonlyifitisready
            if(floobleLoader.theFlooble!=null)doSomething(floobleLoader.theFlooble);
        }
    }
}

public class UserManager{
    public volatile String lastUser;
    public boolean authenticate(String user, String password){
        boolean valid = passwordIsValid(user, password);
        if(valid){
            User u = new User();
            activeUsers.add(u);
            lastUser = user;
        }
        return valid;
    }
}

@ThreadSafe
public class Person{
    private volatile String firstName;
    private volatile String lastName;
    private volatile intage;
    public String getFirstName(){
        return firstName;
    }
    public String getLastName(){
        return lastName;
    }
    public int getAge(){
        return age;
    }
    public void setFirstName(String firstName){
        this.firstName = firstName;
    }
    public void setLastName(String lastName){
        this.lastName = lastName;
    }
    public void setAge(int age){
        this.age = age;
    }
}

@ThreadSafe
public class CheesyCounter{
    //Employs the cheap read-write lock trick
    //All mutative operations MUST be done with the 'this' lock held
    @GuardedBy("this")
    private volatile int value;
        public int getValue(){
        return value;
    }
    public synchronized int increment(){
        return value++;
    }
}