TweetFollow Us on Twitter

Threading
Volume Number:10
Issue Number:11
Column Tag:Essential Apple Technology

Related Info: Process Manager

Threading Your Apps

Tying it all together

By Randy Thelen, Apple Computer, Inc.

Note: Source code files accompanying article are located on MacTech CD-ROM or source code disks.

About the Author

Randy Thelen - Randy (sometimes known as Random) is the kind of Apple engineer who just keeps coming up with wacky ideas that just might work. In his spare time, he's been playing with Threads way too much, and was last seen listening to They Might Be Giants while excitedly showing off fast, color, bit-shuffling code.

Tying it all together

The Thread Manager is a system software extension which allows applications to have multiple threads of execution. With multiple threads of execution you can easily move the processing of relatively lengthy operations into the background thus creating a more responsive application for your users. In this article we’ll learn what the terminology is, we’ll explore the programming model you’ll want to employ to make best use of threads, and we’ll examine the application programming interface (API).

The Threads Manger extension version 2.0.1 (68K and PowerPC based threads) is available for distribution with your application from Apple for $50 (through APDA) and it is built in to System 7.5. Further, Apple’s future O/S endeavors will be threaded. If you employ a threaded model in current application structure, it will carry over transparently (or requiring only minor API changes) to the next generation system software.

Terminology

A few words from the man. Without using any names (Eric Anderson), there’s this Smart Guy™ over here at Apple who was instrumental in actually packaging the Threads Manager for shipment. He wrote the following paragraphs for developers (I felt it fitting to enclose them in this article for you):

“The Thread Manager is the current MacOS solution for lightweight concurrent processing. Multithreading allows an application process to be broken into simple subprocesses that proceed concurrently in the same overall application context. Conceptually, a thread is the smallest amount of processor context state necessary to encapsulate a computation. Practically speaking, a thread consists of a register set, a program counter, and a stack. Threads have a fast context switch time due to their minimal context state requirement and operate within the application context which gives threads full application global access. Since threads are hosted by an application, threads within a given application share the address space, file access paths and other system resources associated with that application. This high degree of data sharing enables threads to be ‘lightweight’ and the context switches to be very fast relative to the heavyweight context switches between Process Manager processes.

“An execution context requires processor time to get anything done, and there can be only one thread at a time using the processor. So, just like applications, threads are scheduled to share the CPU, and the CPU time is scheduled in one of two ways. The Thread Manager provides both cooperative and preemptive threads. Cooperative threads explicitly indicate when they are giving up the CPU. Preemptive threads can be interrupted and gain control at (most) any time. The basis for the difference is that there are many parts of the MacOS and Toolbox that can not function properly when interrupted and/or executed at arbitrary times. Due to this restriction, threads using such services must be cooperative. Threads that do not use the Toolbox or OS may be preemptive.

“Cooperative threads operate under a scheduling model similar to the Process Manager, wherein they must make explicit calls for other cooperative threads to get control. As a result, they are not limited in the calls they can make as long as yielding calls are properly placed. Preemptive threads operate under a time slice scheduling model; no special calls are required to surrender the CPU for other preemptive or cooperative threads to gain control. For threads which are compute-bound or use MacOS and Toolbox calls that can be interrupted, preemptive threads may be the best choice; the resulting code is cleaner than if partial results were saved and control then handed off to other threads of control.”

That said, let’s make it clear early on that preemptive threads are not supported on the PowerMacintosh at this time and therefore developers are strongly encouraged to use cooperative threads. (In reality, this hasn’t posed much of a problem for most developers, given the number of restrictions for preemptive threads.)

Programming Model

In this section, we’ll discuss how to structure your program. Here’s a block diagram of a basic application:

WNE Loop is, of course, that block of code which you cycle through more rapidly than GetCaretTime() ticks expire. Right? If not, that’s one of the first things we’ll learn about the Threads programming model. It’s actually possible to cycle through your event loop more quickly, giving your customer a more responsive computer.

A thread is, of course, the center piece of this article.

Yielding is the process of giving up the CPU for some period of time. As Eric mentioned in his paragraphs was that preemptive threads are yielded inherently by a timer interrupt; they do not yield. Cooperative threads yield. They call YieldToAnyThread(). When we examine the API, we’ll see this call. For now, let’s just remember that yielding is the process of asking the Thread Manager to find the thread of execution which should execute next.

The circular shapes represent the looping nature of a thread. As it turns out, not all threads loop. Some follow some series of steps: A, B, C, ..., etc. Those threads, if they take a long time, should be making asynchronous I/O calls with yield calls where SyncWait would normally execute. For example,


/* 1 */
AsyncFileManagerCall( &pb);
while( pb.ioResult > 0)
YieldToAnyThread();

In our block diagram, we find the two steps most programs have: the initialization and the WaitNextEvent loop. The WNE loop looks something like this (code snippet from Sprocket, courtesy of Dave Falkenburg - thanks Dave, let’s do lunch real soon):


/* 2 */
Boolean gDone = false;
Boolean gMenuBarNeedsUpdate = false;
long    gRunQuantum = GetCaretTime();
long    gSleepQuantum = 3;
RgnHandle gMouseRegion = nil;
Boolean gHasThreadManager = false;

void MainEventLoop(void)
 {
 EventRecordanEvent;
 unsigned long nextTimeToCheckForEvents = 0;
 
 while (!gDone)
 {
 if (gHasThreadManager)
 YieldToAnyThread();

 if (gMenuBarNeedsUpdate)
 {
 gMenuBarNeedsUpdate = false;
 DrawMenuBar();
 }
 
 if ((gRunQuantum == 0) ||
 (TickCount() > nextTimeToCheckForEvents))
 {
 nextTimeToCheckForEvents = TickCount() + gRunQuantum;
 (void) WaitNextEvent( everyEvent, &anEvent,
 gSleepQuantum, gMouseRegion);
 HandleEvent(&anEvent);
 }
 }
 }

Immediately we find two things: PowerMacintosh WaitNextEvent “smarts” and support for the Thread Manager. The WNE “smarts” is simply a mechanism for throttling the frequency with which WaitNextEvent is called on a PowerMacintosh. (The issue here, if you’re not already familiar with it, is that WNE invokes a context switch from PowerPC code to 68K emulation and if the application calls WNE too frequently then performance goes into the proverbial toilet.)

The Thread Manager support is, as you can see, petty. (There was, one would hope, the appropriate check for the presence of the Thread Manager. We’ll see that code in a couple pages.)

The Toolbox trap YieldToAnyThread() uses trap number $ABF2 (which goes by the name ThreadDispatch, and gets a selector in D0). If we glance back at our block diagram, we see that the Toolbox trap YieldToAnyThread() calls into the Thread Manager. It yields the CPU to one of the other threads of execution within the program context. Each thread is then responsible for calling YieldToAnyThread() frequently enough that two things will happen: one, the cursor, if you’ve got one, will blink with reasonable consistency; second, you’ll want events (mouse downs, etc.) to be handled pretty quickly.

With regard to the insertion point blinking, the rule of thumb here really varies: if you’ve got an arbitrary number of threads (potentially greater than GetCaretTime()’s smallest value), you’ll want to yield before a tick expires; if you’ve only got a few threads, you may want to time your processing using the same kind of TickCount() > someQuantum algorithm as what Dave’s done above.

Regarding events, there is something very important you should be familiar with. The Thread Manager will check to see if any events are pending for the application each time a thread yields. If there are events (or there is an event), the thread that gets time next is the main thread. If the main thread then yields without processing the event (or all events), another thread is executed, but upon the next yield, the main thread will then get time again. It’s an algorithm that ensures two things: first, the main thread gets time often enough to handle incoming events as quickly as threads yield, and second, events are not “starved” (threads are always hungry for CPU time).

Obviously these over-simplified rules won’t work for everybody. Hopefully, after you’ve read the bulk of these articles, you’ll get some feel for where to begin your experimentation for coming up with a processing time model that works best for your application and thread requirements.

Your application will create these threads whenever it’s appropriate to do so. In SortPicts (one of the apps included on the source disk and online sites this month), for example, a thread is created when a window is opened. In ThreadBrot (a threaded Mandelbrot, also on disk and online), threads are created as rectangles within the complex number plane are halved (it’s a divide-and-conquer algorithm) until some lower bound rectangle size is reached - recursive algorithms must always have a base case. In Steve Sisak’s article next month, we’ll see threads created for sending AppleEvents - who’d a thunk it? In short, you’re free to create threads during the execution of your program whenever your process is given time by the process manager. In fact, you can preallocate threads into a pool (which the Thread Manager will maintain for you) and then you can spawn new threads of execution during preemptive threads or during interrupts (remember, in 68K land your A5 world must be set correctly; for PowerPC applications, you must make this call from PowerPC code - or the Threads Manager will crash your application).

API

There are only a couple of calls you need to know about: NewThread, YieldToAnyThread. With these two calls, you could make your programs amazingly responsive. With other calls we’ll discuss, you can do much more.


/* 3 */
FUNCTION NewThread (threadStyle: ThreadStyle;
 threadEntry: ThreadEntryProcPtr;
 threadParam: LONGINT;
 stackSize: Size;
 options: ThreadOptions;
 threadResult: LongIntPtr;
 VAR threadMade: ThreadID):OSErr;

You’ll call NewThread whenever you wish to create a new thread of execution. threadStyles are kPreemptiveThread and kCooperativeThread. Again, unless you’re writing a program for use only on a 68K machine, you’ll want to limit yourself to kCooperativeThread.

Your threadEntry is the address of the function which will get executed when the thread is first executed. You should remember that this entry point will be called only once for your thread. From then on, when you call YieldToAnyThread, your thread will continue execution from the instruction immediately following the yield call.

The threadParam is passed to your thread when it is first called. This allows you to pass a value or the address of an arbitrarily-large data structure to your thread.

The stackSize field defines the size that you believe to be adequate to maintain context switch information, satisfy Toolbox stack requirements, and fulfill your thread’s stack needs. If you pass zero for this field, you will get the default stack size. (You can inspect this size by calling GetDefaultThreadStackSize, and you can set it by calling SetDefaultThreadStackSize.)

The options field allows you to define some characteristics about the thread you want created: kNewSuspend creates a thread which is not inherently eligible for execution; kFPUNotNeeded denotes that (on 68K machines) the FPU context will not be saved on the stack during context switches (this option has no effect on the PowerMacintosh implementation of threads).

The threadResult field will be filled in when your thread actually terminates. It’s return value is placed in the memory pointed to here. The NIL case is handled correctly (that is, nothing is put there if you pass in NIL; this avoids a write to memory location 0).

The threadMade is the ThreadID of the thread just created. You’ll use this ID to refer to threads in the future. For example, if you wish to kill a thread, you may call DisposeThread( threadID);.

And last, but not least, there are error codes to be interpreted. Obviously noErr is a good thing. memFullErr means that the thread wasn’t created because there wasn’t room for the stack or thread structure. paramErr is returned if you attempt to create a kPreemptive thread on a PowerMacintosh or if you don’t use one of the two defined values for thread type in the thread type field.

OK. So now you’ve got a dozen threads running rampant in your application and you need to know how to switch from one to the other to the other to the other and back to the main thread of execution (your WNE loop) so that you can actually get some processing done. No problemo, señor y señyorita programmer.

YieldToAnyThread() will get you around your threads quite simply. It takes no parameters and will simply invoke the Thread Manager scheduler to determine which thread should be next to execute. There will be occasions when you will know best which thread should execute next. On these occasions, you will want to call YieldToThread( threadID).

There are several other useful threads calls, and I’ll cover a few here. For more detail, the entire Thread Manager specifications follow right after this article.

Programming Examples

Let’s look at some code examples to see how these routines are used by a real program. The code we’ll look at does three things: 1) Checks for the complete presence of the Thread Manager; 2) Create the thread; 3) YieldToAnyThread().

Checks for the complete presence of the Thread Manager

Checking for the complete presence of the Thread Manager is pretty simple. First, you need to call Gestalt (thanks to the magic of glue, even Gestalt is compatible across all versions of system software back to 4.3) and check that the ‘thds’ selector is present. Second, you’ll need to check to see that the gestaltThreadMgrPresent bit is set. No problem.

For PowerPC code, you need two additional tests. Third, you need to see that the native library is present (this was added to threads with ThreadManager 2.0 -- thanks to Brad Post). Fourth, you need to confirm that the Code Fragment Manager (CFM) actually resolved the Thread Manager code fragment with your application (a shared library).

The reason for the fourth test is because of two conditions: A) the ThreadsLib library may not have loaded -- low memory conditions with VM off, for example; and, B) you should be “weak” linking your application with the ThreadsLib library. This way, if the ThreadsLib library isn’t present on PowerPC machines, your native code can handle the conditional appropriately (a modeless dialog might mention that some features won’t function because some system software features weren’t found) as opposed to the Finder bringing up a modal dialog, “ThreadsLib couldn’t be found.” Like, what does that mean to most of your users?

Without further ado, here’s the code:


/* 4 */
// Test for the presence of the threads manager
// 1. Is the gestalt selector defined?  If not, we bail immediately
// 2. If we're compiling PPC native code, then check for the ThreadsLibrary
// 3. Also, if we're native, check that CFM actually linked my app to 
the library
// 4. Is the Thread Mgr Present bit set to True?  If not, bail

 if( Gestalt( gestaltThreadMgrAttr, &threadGestaltInfo) != noErr ||
#if defined(powerc) || defined (__powerc)
 threadGestaltInfo & (1<<gestaltThreadsLibraryPresent) == 0 ||
 (Ptr) NewThread == kUnresolvedSymbolAddress ||
#endif
 threadGestaltInfo & (1<<gestaltThreadMgrPresent) == 0)
 {
// This is the bail clause.  Yours may be more elaborate
 printf( "Threads Mgr isn’t present  Can’t run the test.\n");
 return;
 }

Create the Thread

There’s really no mystery about creating new threads, but we’ll walk through an example, just the same.


/* 5 */
pascal void *MyThread_A( void *refCon);
 
myErr = NewThread( kCooperativeThread, MyThreadProc, 
 (void *)0, 0, kFPUNotNeeded + kCreateIfNeeded,
 (void**)nil, &threadID);

The NewThread parameters are: thread type, entry procedure, refcon, size of stack, thread options, where to put a return value (when the thread entry procedure “returns”), and, last, a place to put the ID which identifies the thread just created.

So, what this call does is create a cooperative thread, executing the function MyThreadProc with 0 for a refcon with the default stack size. For options, the floating point unit is not needed and the ThreadManager is given the OK to allocate the thread memory if it is needed (remember the thread pool concept from earlier? yea, that’s what this option affects). If the thread has a return value, I don’t care about it (by passing nil as a Ptr to a void *). Last, when the thread is created I want the thread ID stored in the variable called threadID.

A note to C++ users: Some implementations of C++ (THINK C 5.0 with Objects, for example) allow the creation of Handle-based objects. If your object is Handle-based and you pass the address of an Object variable to this function (or any Mac Toolbox function which may move memory during it’s operation), your object may move! This is a bad thing because the ptr to your object variable will no longer point to your object variable after your object data block moves. Solutions to this conundrum are well understood: the best is to pass the address of a stack-based variable (i.e., local variable). The alternative (which is much uglier, but also viable) is to lock your object with HLock. I suggest the local variable.

After the thread is created, you can call YieldToAnyThread and the first line of the thread entry procedure will execute. A word regarding thread execution order: if you have more than one thread, there is no guarantee that the threads will execute in any particular order from yield call to yield call. The only exception is that the main thread (the thread that is created automagically which contains your main() function) will execute if an event is pending in the event queue. This feature means that if the user presses the mouse button, just as fast as your thread yields, the main thread will be executed and it will be free to call WaitNextEvent, which will simply return with a valid (mdown) event and then you can process the event accordingly.

YieldToAnyThread()

At the heart and soul of a thread, there is a thread procedure which will be executed: once. When that function completes, the thread is deemed dead and is no longer eligible for execution. So for example, logic which reads:


/* 6 */
 main()
 {
 NewThread( MyThreadProc);
 while( true)
 YieldToAnyThread();
 }

 pascal void *MyThreadProc( void *refcon)
 {
 printf( “Hello from thread\n”);
 return nil;
 }

will print only one line, “Hello from thread.” Therefore, once your thread gets control, it needs to have its own looping logic built in. Like,


/* 7 */
 pascal void *MyThreadProc( void *refcon)
 {
 for( i = 0; i < 5; i++)
 {
 printf( “Hello from thread\n”);
 YieldToAnyThread();
 }
 return nil;
 }

This will print 5 “Hello from thread” lines before it terminates.

Please look at the source code which accompanies this article. Next month, look for a case study on an app I wrote called SortPicts (and maybe another about AppleEvents and Threads). Read the Thread Manager Documentation. Reread Hitchhiker’s Guide to the Galaxy. Then take some time off. Enjoy life more. Read back issues of MacTutor and MacTech.

Here’s the code to TestThreads.c. It’s followed by the output it generates.

TestThreads.c


/* 8 */
#include <threads.h>
#include <stdio.h>
#include <GestaltEqu.h>
#if defined(powerc) || defined (__powerc)
#include <FragLoad.h>
#endif

pascal void *MyThread_A( void *refCon);
pascal void *MyThread_B( void *refCon);
pascal void *MyThread_C( void *refCon);

main
void  main( void)
{
 OSErr  errWhatErr;
 int    i;
 ThreadID threadID_A, threadID_B, threadID_C;
 long   threadGestaltInfo;
 
// Test for the presence of the threads manager
// 1. Is the gestalt selector defined?  If not, we bail immediately
// 2. If we're compiling PPC native code, then check for the ThreadsLibrary
// 3. Also, if we're native, check that CFM actually linked my app to 
the library
// 4. Is the Thread Mgr Present bit set to True?  If not, bail

 if( Gestalt( gestaltThreadMgrAttr, &threadGestaltInfo) != noErr ||
#if defined(powerc) || defined (__powerc)
 threadGestaltInfo & (1<<gestaltThreadsLibraryPresent) == 0 ||
 (Ptr) NewThread == kUnresolvedSymbolAddress ||
#endif
 threadGestaltInfo & (1<<gestaltThreadMgrPresent) == 0)
 {
// This is the bail clause.  Yours may be more elaborate
 printf( "Threads Mgr isn't present... Can't run the test.\n");
 return;
 }
// Create 3 threads: A, B, C
 errWhatErr = NewThread( kCooperativeThread, MyThread_A,
 (void *)0, 0, kFPUNotNeeded + kCreateIfNeeded,
 (void**)nil, &threadID_A);
 errWhatErr = NewThread( kCooperativeThread, MyThread_B,
 (void *)0, 0, kFPUNotNeeded + kCreateIfNeeded,
 (void**)nil, &threadID_B);
 errWhatErr = NewThread( kCooperativeThread, MyThread_C, 
 (void *)0, 0, kFPUNotNeeded + kCreateIfNeeded,
 (void**)nil, &threadID_C);
// Simple loop to test Yielding
 for( i = 0; i < 5; i++) {
 printf( "This is thread main\n");
 YieldToAnyThread();
 }
}
MyThread_A
pascal void *MyThread_A( void * /* refCon */)
{
 int    i;
 for( i = 0; i < 5; i++) {
 printf( "------- A ------\n");
 YieldToAnyThread();
 }
 return nil;
}
MyThread_B
pascal void *MyThread_B( void * /* refCon */)
{
 int    i;
 for( i = 0; i < 5; i++) {
 printf( "------- B ------\n");
 YieldToAnyThread();
 }
 return nil;
}
MyThread_C
pascal void *MyThread_C( void * /* refCon */)
{
 int    i;
 for( i = 0; i < 5; i++) {
 printf( "------- C ------\n");
 YieldToAnyThread();
 }
 return nil;
}

TestThreads produces the following output when run (note that, although the order of execution appears deterministic, you shouldn’t rely on that behavior):

This is thread main

------- A ------

------- B ------

------- C ------

This is thread main

------- A ------

------- B ------

------- C ------

This is thread main

------- A ------

------- B ------

------- C ------

This is thread main

------- A ------

------- B ------

------- C ------

This is thread main

------- A ------

------- B ------

------- C ------

 

Community Search:
MacTech Search:

Software Updates via MacUpdate

SpamSieve 2.9.38 - Robust spam filter fo...
SpamSieve is a robust spam filter for major email clients that uses powerful Bayesian spam filtering. SpamSieve understands what your spam looks like in order to block it all, but also learns what... Read more
TeamViewer 15.0.8397 - Establish remote...
TeamViewer gives you remote control of any computer or Mac over the Internet within seconds or can be used for online meetings. Find out why more than 200 million users trust TeamViewer! Free for non... Read more
SteerMouse 5.4.3 - Powerful third-party...
SteerMouse is an advanced driver for USB and Bluetooth mice. SteerMouse can assign various functions to buttons that Apple's software does not allow, including double-clicks, modifier clicks,... Read more
Toast Titanium 18.2.1 - The ultimate med...
Roxio Toast Titanium, the leading DVD burner for Mac, makes burning even better, adding Roxio Secure Burn to protect your files on disc and USB in Mac- or Windows-compatible formats. Get more style... Read more
HoudahSpot 5.0.11 - Advanced file-search...
HoudahSpot is a versatile desktop search tool. Use HoudahSpot to locate hard-to-find files and keep frequently used files within reach. HoudahSpot will immediately feel familiar. It works just the... Read more
ClipGrab 3.8.6 - Download videos from Yo...
ClipGrab is a free downloader and converter for YouTube, Vimeo, Facebook and many other online video sites. It converts downloaded videos to MPEG4, MP3 or other formats in just one easy step Version... Read more
ExpanDrive 7.4.0 - Access cloud storage...
ExpanDrive builds cloud storage in every application, acts just like a USB drive plugged into your Mac. With ExpanDrive, you can securely access any remote file server directly from the Finder or... Read more
Adobe Dreamweaver CC 2020 20.0 - Build w...
Dreamweaver CC 2020 is available as part of Adobe Creative Cloud for as little as $20.99/month (or $9.99/month if you're a previous Dreamweaver customer). Adobe Dreamweaver CC 2020 allows you to... Read more
Eye Candy 7.2.3.85 - 30 professional Pho...
Eye Candy renders realistic effects that are difficult or impossible to achieve in Photoshop alone, such as Fire, Chrome, and the new Lightning. Effects like Animal Fur, Smoke, and Reptile Skin are... Read more
Sparkle Pro 2.8.5 - Visual website creat...
Sparkle Pro will change your mind if you thought building websites wasn't for you. Sparkle is the intuitive site builder that lets you create sites for your online portfolio, team or band pages, or... Read more

Latest Forum Discussions

See All

Pre-register for Hello Kitty AR: Kawaii...
Hello Kitty — the cute cat that launched a multi-billion-pound franchise — has been brought to life… sort of. Sanrio has teamed up with the Bublar Group to create a new mobile game that uses AR tech to turn the real world into Hello Kitty’s... | Read more »
Gorgeous and tranquil puzzler Spring Fal...
One-man indie studio SPARSE//GameDev has now launched its tranquil puzzler, Spring Falls. It's described as "a peaceful puzzle game about water, erosion, and watching things grow". [Read more] | Read more »
Black Desert Mobile gets an official rel...
Pearl Abyss has just announced that its highly-anticipated MMO, Black Desert Mobile, will launch globally for iOS and Android on December 11th. [Read more] | Read more »
Another Eden receives new a episode, cha...
Another Eden, WFS' popular RPG, has received another update that brings new story content to the game alongside a few new heroes to discover. [Read more] | Read more »
Overdox guide - Tips and tricks for begi...
Overdox is a clever battle royale that changes things up by adding MOBA mechanics and melee combat to the mix. This new hybrid game can be quite a bit to take in at first, so we’ve put together a list of tips to help you get a leg up on the... | Read more »
Roterra Extreme - Great Escape is a pers...
Roterra Extreme – Great Escape has been described by developers Dig-It Games as a mini-sequel to their acclaimed title Roterra: Flip the Fairytale. It continues that game's tradition of messing with which way is up, tasking you with solving... | Read more »
Hearthstone: Battlegrounds open beta lau...
Remember earlier this year when auto battlers were the latest hotness? We had Auto Chess, DOTA Underlords, Chess Rush, and more all gunning for our attention. They all had their own reasons to play, but, at least from where I'm standing, most... | Read more »
The House of Da Vinci 2 gets a new gamep...
The House of Da Vinci launched all the way back in 2017. Now, developer Blue Brain Games is gearing up to deliver a second dose of The Room-inspired puzzling. Some fresh details have now emerged, alongside the game's first official trailer. [Read... | Read more »
Shoot 'em up action awaits in Battl...
BattleBrew Productions has just introduced another entry into its award winning, barrelpunk inspired, BattleSky Brigade series. Whilst its previous title BattleSky Brigade TapTap provided fans with idle town building gameplay, this time the... | Read more »
Arcade classic R-Type Dimensions EX blas...
If you're a long time fan of shmups and have been looking for something to play lately, Tozai Games may have just released an ideal game for you on iOS. R-Type Dimensions EX brings the first R-Type and its sequel to iOS devices. [Read more] | Read more »

Price Scanner via MacPrices.net

13″ 2.4GHz MacBook Pros available for up to $...
Apple has a full line of Certified Refurbished 2019 13″ 2.4GHz 4-Core Touch Bar MacBook Pros available starting at $1529 and up to $300 off MSRP. Apple’s one-year warranty is included, shipping is... Read more
New at T-Mobile: Switch to T-Mobile, and get...
T-Mobile is offering a free 64GB iPhone 8 for new customers who switch to T-Mobile and open a new line of service. Eligible trade-in required, and discount applied over a 24 month period. The fine... Read more
Xfinity Mobile’s Black Friday Apple savings:...
Take $250 off the purchase of any iPhone at Xfinity Mobile with a new line activation, and transfer of phone number to Xfinity Mobile, through December 8, 2019. This includes Apple’s new iPhone 11... Read more
2019 13″ 1.4GHz MacBook Pros available starti...
Apple has a full line of Certified Refurbished 2019 13″ 1.4GHz 4-Core Touch Bar MacBook Pros available starting at $1099 and up to $230 off MSRP. Apple’s one-year warranty is included, shipping is... Read more
Save up to $350 on a 21″ or 27″ iMac with the...
Apple has Certified Refurbished 2019 21″ & 27″ iMacs available starting at $929 and up to $350 off the cost of new models. Apple’s one-year warranty is standard, shipping is free, and each iMac... Read more
Early Holiday 2019 Sale: B&H again offers...
B&H Photo has 10.2″ iPads on sale again for $30 off Apple’s MSRP, starting at $299, as part of their early Holiday 2019 sale. Overnight shipping is free to many addresses in the US: – 10.2″ 32GB... Read more
Apple iMacs on sale today at B&H Photo fo...
B&H Photo has new 2019 21″ and 27″ 5K iMacs on stock today and on sale for up to $150 off Apple’s MSRP. Overnight shipping is free to many locations in the US. These are the same iMacs sold by... Read more
2018 4 and 6-Core Mac minis on sale today for...
Apple resellers are offering new 2018 4-Core and 6-Core Mac minis for $80-$100 off MSRP for a limited time. B&H Photo has the new 2018 4-Core and 6-Core Mac minis on sale for up to $100 off Apple... Read more
Early Holiday 2019 sale at B&H Photo: 12....
B&H Photo has new 12.9″ iPad Pros on sale for up to $120 off Apple’s MSRP as part of their early Holiday 2019 sale. Overnight shipping is free to many addresses in the US: – 12.9″ 64GB WiFi iPad... Read more
8-Core iMac Pro on sale today for $4499 at B...
B&H Photo has the base 8-Core 3.2GHz 32GB/1TB iMac Pro on sale today for $4499 — $500 off Apple’s MSRP. Shipping is free. Their price is the lowest available for a new iMac Pro from any Apple... Read more

Jobs Board

*Apple* Health Benefit Specialist - Call Cen...
Description ** Apple Health Benefit Specialist - Call Center (MAS 3/MACSC)** **Olympia, WA Multiple Positions** *The ideal candidate for this position will have Read more
Hair Stylist - *Apple* Blossom Mall - JCPen...
Hair Stylist - Apple Blossom Mall Location:Winchester, VA, United States- Apple Blossom Mall 1850 Apple Blossom Dr Job ID:1065040Salon Professionals Job Read more
*Apple* Mobility Pro - Best Buy (United Stat...
**747088BR** **Job Title:** Apple Mobility Pro **Job Category:** Store Associates **Store NUmber or Department:** 000297-Reston-Store **Job Description:** At Best Read more
Nurse Practitioner - Field Based (San Bernard...
Nurse Practitioner - Field Based (San Bernardino, CA, Apple Valley, Hesperia) **Location:** **United States** **Requisition #:** PS30312 **Post Date:** Nov 11, 2019 Read more
Best Buy *Apple* Computing Master - Best Bu...
**747061BR** **Job Title:** Best Buy Apple Computing Master **Job Category:** Store Associates **Store NUmber or Department:** 000647-Kildeer-Store **Job Read more
All contents are Copyright 1984-2011 by Xplain Corporation. All rights reserved. Theme designed by Icreon.